Remove isOSS guards from Fantom renderer tests (#58447)

Summary:
Pull Request resolved: https://github.com/react/react-native/pull/58447

Remove the isOSS conditionals that were skipping Fantom renderer tests in OSS environments. Now that the React Native renderers have been upgraded and the code is compatible in OSS, these tests can run in both internal and OSS environments.

Changes:
- ResponderEventTarget-itest.js: Removed isOSS check that skipped the entire Responder System test suite
- EventTargetDispatching-itest.js: Removed isOSS check that skipped the entire EventTarget-based Event Dispatching test suite
- EventDispatching-benchmark-itest.js: Removed if (isOSS) block that provided a dummy test instead of the benchmark suite
- EventDispatching-itest.js: Removed if (!isOSS) condition guarding three tests for native event timeStamp and global event dispatching

Changelog: [Internal]

Reviewed By: andrewdacenko

Differential Revision: D107675643

fbshipit-source-id: e2d66b2dd9f4ab95d2d278ecbef9badca3b667fb
This commit is contained in:
Rubén Norte authored and meta-codesync[bot] committed 2026-09-10 17:03:25 -07:00
1 parent b0b71421c1
commit a82827ece1
5 files changed
+2040 -2073

No files matched your search

@@ -62,188 +62,26 @@ function createNestedViewsWithLayout(
);
}
const {isOSS} = Fantom.getConstants();
if (isOSS) {
it('is not supported in OSS yet', () => {
expect(true).toBe(true);
});
} else {
Fantom.unstable_benchmark
.suite('Event Dispatching')
.test(
'dispatch event, flat (1 handler)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
Fantom.unstable_benchmark
.suite('Event Dispatching')
.test(
'dispatch event, flat (1 handler)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>,
);
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 10 deep (bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(10, ref));
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 50 deep (bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(50, ref));
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 10 deep (no handlers on ancestors)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 10; i++) {
views = <View collapsable={false}>{views}</View>;
}
root.render(views);
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event with stopPropagation, nested 10 deep',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={e => {
e.stopPropagation();
}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 10; i++) {
views = (
<View collapsable={false} onPointerUp={() => {}}>
{views}
</View>
);
}
root.render(views);
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'render + dispatch, flat (handler update cost)',
() => {
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
@@ -254,183 +92,337 @@ if (isOSS) {
/>,
);
});
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 10 deep (bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>,
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(10, ref));
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 50 deep (bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(50, ref));
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event, nested 10 deep (no handlers on ancestors)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 10; i++) {
views = <View collapsable={false}>{views}</View>;
}
root.render(views);
});
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'dispatch event with stopPropagation, nested 10 deep',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={e => {
e.stopPropagation();
}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 10; i++) {
views = (
<View collapsable={false} onPointerUp={() => {}}>
{views}
</View>
);
});
},
afterEach: () => {
root.destroy();
},
}
root.render(views);
});
},
)
.test(
'dispatch event, nested 50 deep (bubbling), stable tree',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
afterEach: () => {
root.destroy();
},
},
)
.test(
'render + dispatch, flat (handler update cost)',
() => {
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>,
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(50, ref));
});
},
afterAll: () => {
root.destroy();
});
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
},
)
.test(
'dispatch event, nested 50 deep (no handlers on ancestors), stable tree',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
beforeEach: () => {
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>,
);
});
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 50; i++) {
views = <View collapsable={false}>{views}</View>;
}
root.render(views);
});
},
afterAll: () => {
root.destroy();
},
afterEach: () => {
root.destroy();
},
)
.test(
'dispatch onLayout event, flat (1 handler)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onLayout={() => {}}
style={{width: 10, height: 10}}
/>,
);
});
// Flush the layout events emitted during the initial layout pass so
// they are not measured as part of the dispatched event below.
Fantom.flushAllNativeEvents();
},
afterAll: () => {
root.destroy();
},
)
.test(
'dispatch event, nested 50 deep (bubbling), stable tree',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViews(50, ref));
});
},
)
.test(
'dispatch onLayout event, nested 10 deep (direct, no bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
afterAll: () => {
root.destroy();
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViewsWithLayout(10, ref));
});
Fantom.flushAllNativeEvents();
},
afterAll: () => {
root.destroy();
},
)
.test(
'dispatch event, nested 50 deep (no handlers on ancestors), stable tree',
() => {
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
let views: React.MixedElement = (
<View
ref={ref}
collapsable={false}
onPointerUp={() => {}}
style={{width: 10, height: 10}}
/>
);
for (let i = 0; i < 50; i++) {
views = <View collapsable={false}>{views}</View>;
}
root.render(views);
});
},
)
.test(
'dispatch onLayout event, nested 50 deep (direct, no bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
afterAll: () => {
root.destroy();
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViewsWithLayout(50, ref));
});
Fantom.flushAllNativeEvents();
},
afterAll: () => {
root.destroy();
},
)
.test(
'dispatch onLayout event, flat (1 handler)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(
<View
ref={ref}
collapsable={false}
onLayout={() => {}}
style={{width: 10, height: 10}}
/>,
);
});
// Flush the layout events emitted during the initial layout pass so
// they are not measured as part of the dispatched event below.
Fantom.flushAllNativeEvents();
},
);
}
afterAll: () => {
root.destroy();
},
},
)
.test(
'dispatch onLayout event, nested 10 deep (direct, no bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViewsWithLayout(10, ref));
});
Fantom.flushAllNativeEvents();
},
afterAll: () => {
root.destroy();
},
},
)
.test(
'dispatch onLayout event, nested 50 deep (direct, no bubbling)',
() => {
Fantom.dispatchNativeEvent(
ref,
'onLayout',
{layout: {x: 0, y: 0, width: 100, height: 50}},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
},
{
beforeAll: () => {
ref = React.createRef();
root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(createNestedViewsWithLayout(50, ref));
});
Fantom.flushAllNativeEvents();
},
afterAll: () => {
root.destroy();
},
},
);
@@ -20,112 +20,106 @@ import * as FabricUIManager from 'react-native/Libraries/ReactNative/FabricUIMan
const UIManager = nullthrows(FabricUIManager.getFabricUIManager());
describe('Event Dispatching', () => {
// The OSS renderer hasn't been synced yet to have these changes
// TODO(next-major) Remove this condition
if (!Fantom.getConstants().isOSS) {
it('provides the native event timeStamp (camel case) when available', () => {
const root = Fantom.createRoot();
it('provides the native event timeStamp (camel case) when available', () => {
const root = Fantom.createRoot();
const ref = React.createRef<React.ElementRef<typeof View>>();
const ref = React.createRef<React.ElementRef<typeof View>>();
const onPointerUp = jest.fn((e: PointerEvent) => {
e.persist();
});
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
expect(onPointerUp).toHaveBeenCalledTimes(0);
const NATIVE_EVENT_TIMESTAMP = 1234;
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0, timeStamp: NATIVE_EVENT_TIMESTAMP},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBe(
NATIVE_EVENT_TIMESTAMP,
);
const onPointerUp = jest.fn((e: PointerEvent) => {
e.persist();
});
it('provides a default timeStamp when the native event timeStamp is NOT available', () => {
const root = Fantom.createRoot();
const ref = React.createRef<React.ElementRef<typeof View>>();
const onPointerUp = jest.fn((e: PointerEvent) => {
e.persist();
});
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
expect(onPointerUp).toHaveBeenCalledTimes(0);
const lowerBound = performance.now();
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
const upperBound = performance.now();
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBeGreaterThanOrEqual(
lowerBound,
);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBeLessThanOrEqual(
upperBound,
);
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
it('exposes dispatched events in the global scope', () => {
const root = Fantom.createRoot();
expect(onPointerUp).toHaveBeenCalledTimes(0);
const ref = React.createRef<React.ElementRef<typeof View>>();
const NATIVE_EVENT_TIMESTAMP = 1234;
let globalEventIsDispatchedEvent: boolean = false;
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0, timeStamp: NATIVE_EVENT_TIMESTAMP},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
const onPointerUp = jest.fn((e: PointerEvent) => {
globalEventIsDispatchedEvent = global.event === e;
});
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBe(NATIVE_EVENT_TIMESTAMP);
});
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
it('provides a default timeStamp when the native event timeStamp is NOT available', () => {
const root = Fantom.createRoot();
const globalEventValueBeforeDispatch = {type: 'some-event'};
global.event = globalEventValueBeforeDispatch;
const ref = React.createRef<React.ElementRef<typeof View>>();
expect(onPointerUp).toHaveBeenCalledTimes(0);
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(globalEventIsDispatchedEvent).toBe(true);
expect(global.event).toBe(globalEventValueBeforeDispatch);
const onPointerUp = jest.fn((e: PointerEvent) => {
e.persist();
});
}
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
expect(onPointerUp).toHaveBeenCalledTimes(0);
const lowerBound = performance.now();
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
const upperBound = performance.now();
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBeGreaterThanOrEqual(
lowerBound,
);
expect(onPointerUp.mock.calls[0][0].timeStamp).toBeLessThanOrEqual(
upperBound,
);
});
it('exposes dispatched events in the global scope', () => {
const root = Fantom.createRoot();
const ref = React.createRef<React.ElementRef<typeof View>>();
let globalEventIsDispatchedEvent: boolean = false;
const onPointerUp = jest.fn((e: PointerEvent) => {
globalEventIsDispatchedEvent = global.event === e;
});
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
const globalEventValueBeforeDispatch = {type: 'some-event'};
global.event = globalEventValueBeforeDispatch;
expect(onPointerUp).toHaveBeenCalledTimes(0);
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
expect(onPointerUp).toHaveBeenCalledTimes(1);
expect(globalEventIsDispatchedEvent).toBe(true);
expect(global.event).toBe(globalEventValueBeforeDispatch);
});
it('dispatches events with discrete priority', () => {
const root = Fantom.createRoot();
File diff suppressed because it is too large. Load diff
@@ -46,9 +46,7 @@ function touchEnd(
};
}
const {isOSS} = Fantom.getConstants();
(isOSS ? describe.skip : describe)('Responder System', () => {
describe('Responder System', () => {
// --- Basic Grant / Release ---
it('grants responder on touch start when onStartShouldSetResponder returns true', () => {
@@ -1698,8 +1698,6 @@ describe('ReactNativeElement', () => {
// EventTarget API is gated behind `enableImperativeEvents`: when it is off
// the methods are removed from this final class, when it is on they are
// available.
const {isOSS} = Fantom.getConstants();
if (!ReactNativeFeatureFlags.enableImperativeEvents()) {
describe('when `enableImperativeEvents` is off (default)', () => {
it('removes the public EventTarget methods', () => {
@@ -1720,31 +1718,28 @@ describe('ReactNativeElement', () => {
// Removing the public API must not affect native/prop event delivery,
// which goes through the internal (symbol-keyed) dispatch path.
(isOSS ? it.skip : it)(
'still delivers native events to prop handlers',
() => {
const ref = createRef<HostInstance>();
const onPointerUp = jest.fn();
const root = Fantom.createRoot();
it('still delivers native events to prop handlers', () => {
const ref = createRef<HostInstance>();
const onPointerUp = jest.fn();
const root = Fantom.createRoot();
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
Fantom.runTask(() => {
root.render(<View ref={ref} onPointerUp={onPointerUp} />);
});
expect(onPointerUp).toHaveBeenCalledTimes(0);
expect(onPointerUp).toHaveBeenCalledTimes(0);
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
Fantom.dispatchNativeEvent(
ref,
'onPointerUp',
{x: 0, y: 0},
{
category: Fantom.NativeEventCategory.Discrete,
},
);
expect(onPointerUp).toHaveBeenCalledTimes(1);
},
);
expect(onPointerUp).toHaveBeenCalledTimes(1);
});
});
}