improve test coverage

src/__tests__/fire-event-async.test.tsx

@@ -641,3 +641,21 @@ describe('React.Suspense integration', () => {
     expect(screen.getByText('Loading data...')).toBeTruthy();
   });
 });
+
+test('should handle unmounted elements gracefully in async mode', async () => {
+  const onPress = jest.fn();
+  const result = render(
+    <TouchableOpacity onPress={onPress}>
+      <Text>Test</Text>
+    </TouchableOpacity>,
+  );
+
+  const element = screen.getByText('Test');
+
+  // Unmount the component
+  result.unmount();
+
+  // Firing async event on unmounted element should not crash
+  await fireEventAsync.press(element);
+  expect(onPress).not.toHaveBeenCalled();
+});

src/__tests__/fire-event.test.tsx

@@ -553,3 +553,47 @@ describe('native events', () => {
     expect(onMomentumScrollEndSpy).toHaveBeenCalled();
   });
 });
+
+test('should handle unmounted elements gracefully', () => {
+  const onPress = jest.fn();
+  const result = render(
+    <TouchableOpacity onPress={onPress}>
+      <Text>Test</Text>
+    </TouchableOpacity>,
+  );
+
+  const element = screen.getByText('Test');
+
+  // Unmount the component
+  result.unmount();
+
+  // Firing event on unmounted element should not crash
+  fireEvent.press(element);
+  expect(onPress).not.toHaveBeenCalled();
+});
+
+test('should handle invalid scroll event data gracefully', () => {
+  const onScrollSpy = jest.fn();
+  render(<ScrollView testID="scroll-view" onScroll={onScrollSpy} />);
+
+  const scrollView = screen.getByTestId('scroll-view');
+
+  // Test with malformed event data that would cause an error in tryGetContentOffset
+  fireEvent.scroll(scrollView, { malformed: 'data' });
+  expect(onScrollSpy).toHaveBeenCalled();
+});
+
+test('should handle scroll event with invalid contentOffset', () => {
+  const onScrollSpy = jest.fn();
+  render(<ScrollView testID="scroll-view" onScroll={onScrollSpy} />);
+
+  const scrollView = screen.getByTestId('scroll-view');
+
+  // Test with event data that has invalid contentOffset structure
+  fireEvent.scroll(scrollView, {
+    nativeEvent: {
+      contentOffset: { x: 'invalid', y: null },
+    },
+  });
+  expect(onScrollSpy).toHaveBeenCalled();
+});

src/__tests__/render-async.test.tsx

@@ -0,0 +1,143 @@
+import * as React from 'react';
+import { Text, View } from 'react-native';
+
+import { renderAsync, screen } from '..';
+
+class Banana extends React.Component<any, { fresh: boolean }> {
+  state = {
+    fresh: false,
+  };
+
+  componentDidUpdate() {
+    if (this.props.onUpdate) {
+      this.props.onUpdate();
+    }
+  }
+
+  componentWillUnmount() {
+    if (this.props.onUnmount) {
+      this.props.onUnmount();
+    }
+  }
+
+  changeFresh = () => {
+    this.setState((state) => ({
+      fresh: !state.fresh,
+    }));
+  };
+
+  render() {
+    return (
+      <View>
+        <Text>Is the banana fresh?</Text>
+        <Text testID="bananaFresh">{this.state.fresh ? 'fresh' : 'not fresh'}</Text>
+      </View>
+    );
+  }
+}
+
+test('renderAsync renders component asynchronously', async () => {
+  await renderAsync(<View testID="test" />);
+  expect(screen.getByTestId('test')).toBeOnTheScreen();
+});
+
+test('renderAsync with wrapper option', async () => {
+  const WrapperComponent = ({ children }: { children: React.ReactNode }) => (
+    <View testID="wrapper">{children}</View>
+  );
+
+  await renderAsync(<View testID="inner" />, {
+    wrapper: WrapperComponent,
+  });
+
+  expect(screen.getByTestId('wrapper')).toBeTruthy();
+  expect(screen.getByTestId('inner')).toBeTruthy();
+});
+
+test('renderAsync supports concurrent rendering option', async () => {
+  await renderAsync(<View testID="test" />, { concurrentRoot: true });
+  expect(screen.root).toBeOnTheScreen();
+});
+
+test('renderAsync supports legacy rendering option', async () => {
+  await renderAsync(<View testID="test" />, { concurrentRoot: false });
+  expect(screen.root).toBeOnTheScreen();
+});
+
+test('update function updates component synchronously', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUpdate={fn} />);
+
+  result.update(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('updateAsync function updates component asynchronously', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUpdate={fn} />);
+
+  await result.updateAsync(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('rerender is an alias for update', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUpdate={fn} />);
+
+  result.rerender(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('rerenderAsync is an alias for updateAsync', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUpdate={fn} />);
+
+  await result.rerenderAsync(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('unmount function unmounts component synchronously', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUnmount={fn} />);
+
+  result.unmount();
+
+  expect(fn).toHaveBeenCalled();
+});
+
+test('unmountAsync function unmounts component asynchronously', async () => {
+  const fn = jest.fn();
+  const result = await renderAsync(<Banana onUnmount={fn} />);
+
+  await result.unmountAsync();
+
+  expect(fn).toHaveBeenCalled();
+});
+
+test('container property displays deprecation message', async () => {
+  await renderAsync(<View testID="inner" />);
+
+  expect(() => (screen as any).container).toThrowErrorMatchingInlineSnapshot(`
+    "'container' property has been renamed to 'UNSAFE_root'.
+
+    Consider using 'root' property which returns root host element."
+  `);
+});
+
+test('debug function handles null JSON', async () => {
+  const result = await renderAsync(<View testID="test" />);
+
+  // Mock toJSON to return null to test the debug edge case
+  const originalToJSON = result.toJSON;
+  (result as any).toJSON = jest.fn().mockReturnValue(null);
+
+  // This should not throw and handle null JSON gracefully
+  expect(() => result.debug()).not.toThrow();
+
+  // Restore original toJSON
+  (result as any).toJSON = originalToJSON;
+});

src/__tests__/render.test.tsx

@@ -243,3 +243,30 @@ test('supports concurrent rendering', () => {
   render(<View testID="test" />, { concurrentRoot: true });
   expect(screen.root).toBeOnTheScreen();
 });
+
+test('updateAsync updates the component asynchronously', async () => {
+  const fn = jest.fn();
+  const result = render(<Banana onUpdate={fn} />);
+
+  await result.updateAsync(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('rerenderAsync is an alias for updateAsync', async () => {
+  const fn = jest.fn();
+  const result = render(<Banana onUpdate={fn} />);
+
+  await result.rerenderAsync(<Banana onUpdate={fn} />);
+
+  expect(fn).toHaveBeenCalledTimes(1);
+});
+
+test('unmountAsync unmounts the component asynchronously', async () => {
+  const fn = jest.fn();
+  const result = render(<Banana onUnmount={fn} />);
+
+  await result.unmountAsync();
+
+  expect(fn).toHaveBeenCalled();
+});