diff --git a/packages/react-dom/src/events/plugins/__tests__/SimpleEventPlugin-test.js b/packages/react-dom/src/events/plugins/__tests__/SimpleEventPlugin-test.js
index 005ccfc0acd35..ac0096d7251f1 100644
--- a/packages/react-dom/src/events/plugins/__tests__/SimpleEventPlugin-test.js
+++ b/packages/react-dom/src/events/plugins/__tests__/SimpleEventPlugin-test.js
@@ -18,6 +18,8 @@ describe('SimpleEventPlugin', function () {
 
   let onClick;
   let container;
+  let assertLog;
+  let waitForAll;
 
   function expectClickThru(element) {
     element.click();
@@ -43,6 +45,10 @@ describe('SimpleEventPlugin', function () {
     ReactDOMClient = require('react-dom/client');
     Scheduler = require('scheduler');
 
+    const InternalTestUtils = require('internal-test-utils');
+    assertLog = InternalTestUtils.assertLog;
+    waitForAll = InternalTestUtils.waitForAll;
+
     onClick = jest.fn();
   });
 
@@ -222,12 +228,12 @@ describe('SimpleEventPlugin', function () {
 
     ReactDOM.render(<Button />, container);
     expect(button.textContent).toEqual('Count: 0');
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
 
     click();
 
     // There should be exactly one update.
-    expect(Scheduler).toHaveYielded(['didUpdate - Count: 3']);
+    assertLog(['didUpdate - Count: 3']);
     expect(button.textContent).toEqual('Count: 3');
   });
 
@@ -240,6 +246,10 @@ describe('SimpleEventPlugin', function () {
       ReactDOMClient = require('react-dom/client');
       Scheduler = require('scheduler');
 
+      const InternalTestUtils = require('internal-test-utils');
+      assertLog = InternalTestUtils.assertLog;
+      waitForAll = InternalTestUtils.waitForAll;
+
       act = require('jest-react').act;
     });
 
@@ -274,10 +284,10 @@ describe('SimpleEventPlugin', function () {
       // Initial mount
       root.render(<Button />);
       // Should not have flushed yet because it's async
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
       expect(button).toBe(undefined);
       // Flush async work
-      expect(Scheduler).toFlushAndYield(['render button: enabled']);
+      await waitForAll(['render button: enabled']);
 
       function click() {
         const event = new MouseEvent('click', {
@@ -292,7 +302,7 @@ describe('SimpleEventPlugin', function () {
 
       // Click the button to trigger the side-effect
       await act(async () => click());
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // The handler fired
         'Side-effect',
         // The component re-rendered synchronously, even in concurrent mode.
@@ -301,7 +311,7 @@ describe('SimpleEventPlugin', function () {
 
       // Click the button again
       click();
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // The event handler was removed from the button, so there's no effect.
       ]);
 
@@ -312,7 +322,7 @@ describe('SimpleEventPlugin', function () {
       click();
       click();
       click();
-      expect(Scheduler).toFlushAndYield([]);
+      await waitForAll([]);
     });
 
     // NOTE: This test was written for the old behavior of discrete updates,
@@ -345,7 +355,7 @@ describe('SimpleEventPlugin', function () {
       // Should not have flushed yet because it's async
       expect(button).toBe(undefined);
       // Flush async work
-      Scheduler.unstable_flushAll();
+      await waitForAll([]);
       expect(button.textContent).toEqual('Count: 0');
 
       function click() {
@@ -373,7 +383,7 @@ describe('SimpleEventPlugin', function () {
       await act(async () => click());
 
       // Flush the remaining work
-      Scheduler.unstable_flushAll();
+      await waitForAll([]);
       // The counter should equal the total number of clicks
       expect(button.textContent).toEqual('Count: 7');
     });
diff --git a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
index f27502094cad0..453fc579d1d22 100644
--- a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
@@ -18,6 +18,8 @@ let ReactTestRenderer;
 let Scheduler;
 let ReactDOMServer;
 let act;
+let assertLog;
+let waitForAll;
 
 describe('ReactHooks', () => {
   beforeEach(() => {
@@ -30,6 +32,10 @@ describe('ReactHooks', () => {
     Scheduler = require('scheduler');
     ReactDOMServer = require('react-dom/server');
     act = require('jest-react').act;
+
+    const InternalTestUtils = require('internal-test-utils');
+    assertLog = InternalTestUtils.assertLog;
+    waitForAll = InternalTestUtils.waitForAll;
   });
 
   if (__DEV__) {
@@ -54,7 +60,7 @@ describe('ReactHooks', () => {
     });
   }
 
-  it('bails out in the render phase if all of the state is the same', () => {
+  it('bails out in the render phase if all of the state is the same', async () => {
     const {useState, useLayoutEffect} = React;
 
     function Child({text}) {
@@ -80,11 +86,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Parent />);
-    expect(Scheduler).toFlushAndYield([
-      'Parent: 0, 0',
-      'Child: 0, 0',
-      'Effect: 0, 0',
-    ]);
+    await waitForAll(['Parent: 0, 0', 'Child: 0, 0', 'Effect: 0, 0']);
     expect(root).toMatchRenderedOutput('0, 0');
 
     // Normal update
@@ -93,15 +95,11 @@ describe('ReactHooks', () => {
       setCounter2(1);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1, 1',
-      'Child: 1, 1',
-      'Effect: 1, 1',
-    ]);
+    assertLog(['Parent: 1, 1', 'Child: 1, 1', 'Effect: 1, 1']);
 
     // Update that bails out.
     act(() => setCounter1(1));
-    expect(Scheduler).toHaveYielded(['Parent: 1, 1']);
+    assertLog(['Parent: 1, 1']);
 
     // This time, one of the state updates but the other one doesn't. So we
     // can't bail out.
@@ -110,11 +108,7 @@ describe('ReactHooks', () => {
       setCounter2(2);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1, 2',
-      'Child: 1, 2',
-      'Effect: 1, 2',
-    ]);
+    assertLog(['Parent: 1, 2', 'Child: 1, 2', 'Effect: 1, 2']);
 
     // Lots of updates that eventually resolve to the current values.
     act(() => {
@@ -128,7 +122,7 @@ describe('ReactHooks', () => {
 
     // Because the final values are the same as the current values, the
     // component bails out.
-    expect(Scheduler).toHaveYielded(['Parent: 1, 2']);
+    assertLog(['Parent: 1, 2']);
 
     // prepare to check SameValue
     act(() => {
@@ -136,11 +130,7 @@ describe('ReactHooks', () => {
       setCounter2(NaN);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 0, NaN',
-      'Child: 0, NaN',
-      'Effect: 0, NaN',
-    ]);
+    assertLog(['Parent: 0, NaN', 'Child: 0, NaN', 'Effect: 0, NaN']);
 
     // check if re-setting to negative 0 / NaN still bails out
     act(() => {
@@ -150,20 +140,16 @@ describe('ReactHooks', () => {
       setCounter2(NaN);
     });
 
-    expect(Scheduler).toHaveYielded(['Parent: 0, NaN']);
+    assertLog(['Parent: 0, NaN']);
 
     // check if changing negative 0 to positive 0 does not bail out
     act(() => {
       setCounter1(0);
     });
-    expect(Scheduler).toHaveYielded([
-      'Parent: 0, NaN',
-      'Child: 0, NaN',
-      'Effect: 0, NaN',
-    ]);
+    assertLog(['Parent: 0, NaN', 'Child: 0, NaN', 'Effect: 0, NaN']);
   });
 
-  it('bails out in render phase if all the state is the same and props bail out with memo', () => {
+  it('bails out in render phase if all the state is the same and props bail out with memo', async () => {
     const {useState, memo} = React;
 
     function Child({text}) {
@@ -188,10 +174,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Parent theme="light" />);
-    expect(Scheduler).toFlushAndYield([
-      'Parent: 0, 0 (light)',
-      'Child: 0, 0 (light)',
-    ]);
+    await waitForAll(['Parent: 0, 0 (light)', 'Child: 0, 0 (light)']);
     expect(root).toMatchRenderedOutput('0, 0 (light)');
 
     // Normal update
@@ -200,14 +183,11 @@ describe('ReactHooks', () => {
       setCounter2(1);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1, 1 (light)',
-      'Child: 1, 1 (light)',
-    ]);
+    assertLog(['Parent: 1, 1 (light)', 'Child: 1, 1 (light)']);
 
     // Update that bails out.
     act(() => setCounter1(1));
-    expect(Scheduler).toHaveYielded(['Parent: 1, 1 (light)']);
+    assertLog(['Parent: 1, 1 (light)']);
 
     // This time, one of the state updates but the other one doesn't. So we
     // can't bail out.
@@ -216,10 +196,7 @@ describe('ReactHooks', () => {
       setCounter2(2);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1, 2 (light)',
-      'Child: 1, 2 (light)',
-    ]);
+    assertLog(['Parent: 1, 2 (light)', 'Child: 1, 2 (light)']);
 
     // Updates bail out, but component still renders because props
     // have changed
@@ -229,10 +206,7 @@ describe('ReactHooks', () => {
       root.update(<Parent theme="dark" />);
     });
 
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1, 2 (dark)',
-      'Child: 1, 2 (dark)',
-    ]);
+    assertLog(['Parent: 1, 2 (dark)', 'Child: 1, 2 (dark)']);
 
     // Both props and state bail out
     act(() => {
@@ -241,10 +215,10 @@ describe('ReactHooks', () => {
       root.update(<Parent theme="dark" />);
     });
 
-    expect(Scheduler).toHaveYielded(['Parent: 1, 2 (dark)']);
+    assertLog(['Parent: 1, 2 (dark)']);
   });
 
-  it('warns about setState second argument', () => {
+  it('warns about setState second argument', async () => {
     const {useState} = React;
 
     let setCounter;
@@ -258,7 +232,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Counter />);
-    expect(Scheduler).toFlushAndYield(['Count: 0']);
+    await waitForAll(['Count: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     expect(() => {
@@ -274,11 +248,11 @@ describe('ReactHooks', () => {
         'declare it in the component body with useEffect().',
       {withoutStack: true},
     );
-    expect(Scheduler).toHaveYielded(['Count: 1']);
+    assertLog(['Count: 1']);
     expect(root).toMatchRenderedOutput('1');
   });
 
-  it('warns about dispatch second argument', () => {
+  it('warns about dispatch second argument', async () => {
     const {useReducer} = React;
 
     let dispatch;
@@ -292,7 +266,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Counter />);
-    expect(Scheduler).toFlushAndYield(['Count: 0']);
+    await waitForAll(['Count: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     expect(() => {
@@ -308,11 +282,11 @@ describe('ReactHooks', () => {
         'declare it in the component body with useEffect().',
       {withoutStack: true},
     );
-    expect(Scheduler).toHaveYielded(['Count: 1']);
+    assertLog(['Count: 1']);
     expect(root).toMatchRenderedOutput('1');
   });
 
-  it('never bails out if context has changed', () => {
+  it('never bails out if context has changed', async () => {
     const {useState, useLayoutEffect, useContext} = React;
 
     const ThemeContext = React.createContext('light');
@@ -355,7 +329,7 @@ describe('ReactHooks', () => {
       );
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Theme: light',
       'Parent: 0 (light)',
       'Child: 0 (light)',
@@ -366,21 +340,17 @@ describe('ReactHooks', () => {
     // Updating the theme to the same value doesn't cause the consumers
     // to re-render.
     setTheme('light');
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('0 (light)');
 
     // Normal update
     act(() => setCounter(1));
-    expect(Scheduler).toHaveYielded([
-      'Parent: 1 (light)',
-      'Child: 1 (light)',
-      'Effect: 1 (light)',
-    ]);
+    assertLog(['Parent: 1 (light)', 'Child: 1 (light)', 'Effect: 1 (light)']);
     expect(root).toMatchRenderedOutput('1 (light)');
 
     // Update that doesn't change state, so it bails out
     act(() => setCounter(1));
-    expect(Scheduler).toHaveYielded(['Parent: 1 (light)']);
+    assertLog(['Parent: 1 (light)']);
     expect(root).toMatchRenderedOutput('1 (light)');
 
     // Update that doesn't change state, but the context changes, too, so it
@@ -390,7 +360,7 @@ describe('ReactHooks', () => {
       setTheme('dark');
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Theme: dark',
       'Parent: 1 (dark)',
       'Child: 1 (dark)',
@@ -399,7 +369,7 @@ describe('ReactHooks', () => {
     expect(root).toMatchRenderedOutput('1 (dark)');
   });
 
-  it('can bail out without calling render phase (as an optimization) if queue is known to be empty', () => {
+  it('can bail out without calling render phase (as an optimization) if queue is known to be empty', async () => {
     const {useState, useLayoutEffect} = React;
 
     function Child({text}) {
@@ -420,12 +390,12 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Parent />);
-    expect(Scheduler).toFlushAndYield(['Parent: 0', 'Child: 0', 'Effect: 0']);
+    await waitForAll(['Parent: 0', 'Child: 0', 'Effect: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     // Normal update
     act(() => setCounter(1));
-    expect(Scheduler).toHaveYielded(['Parent: 1', 'Child: 1', 'Effect: 1']);
+    assertLog(['Parent: 1', 'Child: 1', 'Effect: 1']);
     expect(root).toMatchRenderedOutput('1');
 
     // Update to the same state. React doesn't know if the queue is empty
@@ -433,25 +403,25 @@ describe('ReactHooks', () => {
     // enter the render phase before we can bail out. But we bail out before
     // rendering the child, and we don't fire any effects.
     act(() => setCounter(1));
-    expect(Scheduler).toHaveYielded(['Parent: 1']);
+    assertLog(['Parent: 1']);
     expect(root).toMatchRenderedOutput('1');
 
     // Update to the same state again. This times, neither fiber has pending
     // update priority, so we can bail out before even entering the render phase.
     act(() => setCounter(1));
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('1');
 
     // This changes the state to something different so it renders normally.
     act(() => setCounter(2));
-    expect(Scheduler).toHaveYielded(['Parent: 2', 'Child: 2', 'Effect: 2']);
+    assertLog(['Parent: 2', 'Child: 2', 'Effect: 2']);
     expect(root).toMatchRenderedOutput('2');
 
     // prepare to check SameValue
     act(() => {
       setCounter(0);
     });
-    expect(Scheduler).toHaveYielded(['Parent: 0', 'Child: 0', 'Effect: 0']);
+    assertLog(['Parent: 0', 'Child: 0', 'Effect: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     // Update to the same state for the first time to flush the queue
@@ -459,25 +429,25 @@ describe('ReactHooks', () => {
       setCounter(0);
     });
 
-    expect(Scheduler).toHaveYielded(['Parent: 0']);
+    assertLog(['Parent: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     // Update again to the same state. Should bail out.
     act(() => {
       setCounter(0);
     });
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('0');
 
     // Update to a different state (positive 0 to negative 0)
     act(() => {
       setCounter(0 / -1);
     });
-    expect(Scheduler).toHaveYielded(['Parent: 0', 'Child: 0', 'Effect: 0']);
+    assertLog(['Parent: 0', 'Child: 0', 'Effect: 0']);
     expect(root).toMatchRenderedOutput('0');
   });
 
-  it('bails out multiple times in a row without entering render phase', () => {
+  it('bails out multiple times in a row without entering render phase', async () => {
     const {useState} = React;
 
     function Child({text}) {
@@ -495,7 +465,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Parent />);
-    expect(Scheduler).toFlushAndYield(['Parent: 0', 'Child: 0']);
+    await waitForAll(['Parent: 0', 'Child: 0']);
     expect(root).toMatchRenderedOutput('0');
 
     const update = value => {
@@ -515,7 +485,7 @@ describe('ReactHooks', () => {
       update(3);
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       // The first four updates were eagerly computed, because the queue is
       // empty before each one.
       'Compute state (0 -> 0)',
@@ -527,7 +497,7 @@ describe('ReactHooks', () => {
     ]);
 
     // Now let's enter the render phase
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // We don't need to re-compute the first four updates. Only the final two.
       'Compute state (1 -> 2)',
       'Compute state (2 -> 3)',
@@ -537,7 +507,7 @@ describe('ReactHooks', () => {
     expect(root).toMatchRenderedOutput('3');
   });
 
-  it('can rebase on top of a previously skipped update', () => {
+  it('can rebase on top of a previously skipped update', async () => {
     const {useState} = React;
 
     function Child({text}) {
@@ -555,7 +525,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null, {unstable_isConcurrent: true});
     root.update(<Parent />);
-    expect(Scheduler).toFlushAndYield(['Parent: 1', 'Child: 1']);
+    await waitForAll(['Parent: 1', 'Child: 1']);
     expect(root).toMatchRenderedOutput('1');
 
     const update = compute => {
@@ -576,13 +546,13 @@ describe('ReactHooks', () => {
       ReactTestRenderer.unstable_batchedUpdates(() => update(n => n * 100));
     }
     // The new state is eagerly computed.
-    expect(Scheduler).toHaveYielded(['Compute state (1 -> 100)']);
+    assertLog(['Compute state (1 -> 100)']);
 
     // but before it's flushed, a higher priority update interrupts it.
     root.unstable_flushSync(() => {
       update(n => n + 5);
     });
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       // The eagerly computed state was completely skipped
       'Compute state (1 -> 6)',
       'Parent: 6',
@@ -593,7 +563,7 @@ describe('ReactHooks', () => {
     // Now when we finish the first update, the second update is rebased on top.
     // Notice we didn't have to recompute the first update even though it was
     // skipped in the previous render.
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Compute state (100 -> 105)',
       'Parent: 105',
       'Child: 105',
@@ -612,7 +582,7 @@ describe('ReactHooks', () => {
       return props.dependencies;
     }
     const root = ReactTestRenderer.create(<App dependencies={['A']} />);
-    expect(Scheduler).toHaveYielded(['Did commit: A']);
+    assertLog(['Did commit: A']);
     expect(() => {
       root.update(<App dependencies={['A', 'B']} />);
     }).toErrorDev([
@@ -639,7 +609,7 @@ describe('ReactHooks', () => {
 
     const root = ReactTestRenderer.create(null);
     root.update(<App text="Hello" hasDeps={true} />);
-    expect(Scheduler).toHaveYielded(['Compute']);
+    assertLog(['Compute']);
     expect(root).toMatchRenderedOutput('HELLO');
 
     expect(() => {
@@ -1841,7 +1811,7 @@ describe('ReactHooks', () => {
     );
     expect(root).toMatchRenderedOutput('loading');
     await Promise.resolve();
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('hello');
   });
 
@@ -1873,7 +1843,7 @@ describe('ReactHooks', () => {
     );
     expect(root).toMatchRenderedOutput('loading');
     await Promise.resolve();
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('hello');
   });
 
@@ -1905,7 +1875,7 @@ describe('ReactHooks', () => {
     );
     expect(root).toMatchRenderedOutput('loading');
     await Promise.resolve();
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
     expect(root).toMatchRenderedOutput('hello');
   });
 
diff --git a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
index 6bfd7ae16fed2..9a3bd8efdcd2e 100644
--- a/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactHooksWithNoopRenderer-test.js
@@ -35,6 +35,11 @@ let memo;
 let act;
 let ContinuousEventPriority;
 let SuspenseList;
+let waitForAll;
+let waitFor;
+let waitForThrow;
+let waitForPaint;
+let assertLog;
 
 describe('ReactHooksWithNoopRenderer', () => {
   beforeEach(() => {
@@ -65,6 +70,13 @@ describe('ReactHooksWithNoopRenderer', () => {
       SuspenseList = React.SuspenseList;
     }
 
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    waitForThrow = InternalTestUtils.waitForThrow;
+    waitForPaint = InternalTestUtils.waitForPaint;
+    assertLog = InternalTestUtils.assertLog;
+
     textCache = new Map();
 
     readText = text => {
@@ -151,7 +163,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     return Promise.resolve().then(() => {});
   }
 
-  it('resumes after an interruption', () => {
+  it('resumes after an interruption', async () => {
     function Counter(props, ref) {
       const [count, updateCount] = useState(0);
       useImperativeHandle(ref, () => ({updateCount}));
@@ -162,33 +174,33 @@ describe('ReactHooksWithNoopRenderer', () => {
     // Initial mount
     const counter = React.createRef(null);
     ReactNoop.render(<Counter label="Count" ref={counter} />);
-    expect(Scheduler).toFlushAndYield(['Count: 0']);
+    await waitForAll(['Count: 0']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
     // Schedule some updates
-    act(() => {
+    await act(async () => {
       React.startTransition(() => {
         counter.current.updateCount(1);
         counter.current.updateCount(count => count + 10);
       });
 
       // Partially flush without committing
-      expect(Scheduler).toFlushAndYieldThrough(['Count: 11']);
+      await waitFor(['Count: 11']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       // Interrupt with a high priority update
       ReactNoop.flushSync(() => {
         ReactNoop.render(<Counter label="Total" />);
       });
-      expect(Scheduler).toHaveYielded(['Total: 0']);
+      assertLog(['Total: 0']);
 
       // Resume rendering
-      expect(Scheduler).toFlushAndYield(['Total: 11']);
+      await waitForAll(['Total: 11']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Total: 11" />);
     });
   });
 
-  it('throws inside class components', () => {
+  it('throws inside class components', async () => {
     class BadCounter extends React.Component {
       render() {
         const [count] = useState(0);
@@ -212,11 +224,11 @@ describe('ReactHooksWithNoopRenderer', () => {
       return <Text text={count} />;
     }
     ReactNoop.render(<GoodCounter initialCount={10} />);
-    expect(Scheduler).toFlushAndYield([10]);
+    await waitForAll([10]);
   });
 
   if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
-    it('throws inside module-style components', () => {
+    it('throws inside module-style components', async () => {
       function Counter() {
         return {
           render() {
@@ -249,11 +261,11 @@ describe('ReactHooksWithNoopRenderer', () => {
         return <Text text={count} />;
       }
       ReactNoop.render(<GoodCounter initialCount={10} />);
-      expect(Scheduler).toFlushAndYield([10]);
+      await waitForAll([10]);
     });
   }
 
-  it('throws when called outside the render phase', () => {
+  it('throws when called outside the render phase', async () => {
     expect(() => {
       expect(() => useState(0)).toThrow(
         "Cannot read property 'useState' of null",
@@ -270,7 +282,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('useState', () => {
-    it('simple mount and update', () => {
+    it('simple mount and update', async () => {
       function Counter(props, ref) {
         const [count, updateCount] = useState(0);
         useImperativeHandle(ref, () => ({updateCount}));
@@ -279,19 +291,19 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       act(() => counter.current.updateCount(1));
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
 
       act(() => counter.current.updateCount(count => count + 10));
-      expect(Scheduler).toHaveYielded(['Count: 11']);
+      assertLog(['Count: 11']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 11" />);
     });
 
-    it('lazy state initializer', () => {
+    it('lazy state initializer', async () => {
       function Counter(props, ref) {
         const [count, updateCount] = useState(() => {
           Scheduler.unstable_yieldValue('getInitialState');
@@ -303,15 +315,15 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter initialState={42} ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['getInitialState', 'Count: 42']);
+      await waitForAll(['getInitialState', 'Count: 42']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 42" />);
 
       act(() => counter.current.updateCount(7));
-      expect(Scheduler).toHaveYielded(['Count: 7']);
+      assertLog(['Count: 7']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 7" />);
     });
 
-    it('multiple states', () => {
+    it('multiple states', async () => {
       function Counter(props, ref) {
         const [count, updateCount] = useState(0);
         const [label, updateLabel] = useState('Count');
@@ -321,17 +333,17 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       act(() => counter.current.updateCount(7));
-      expect(Scheduler).toHaveYielded(['Count: 7']);
+      assertLog(['Count: 7']);
 
       act(() => counter.current.updateLabel('Total'));
-      expect(Scheduler).toHaveYielded(['Total: 7']);
+      assertLog(['Total: 7']);
     });
 
-    it('returns the same updater function every time', () => {
+    it('returns the same updater function every time', async () => {
       let updater = null;
       function Counter() {
         const [count, updateCount] = useState(0);
@@ -339,25 +351,25 @@ describe('ReactHooksWithNoopRenderer', () => {
         return <Text text={'Count: ' + count} />;
       }
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       const firstUpdater = updater;
 
       act(() => firstUpdater(1));
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
 
       const secondUpdater = updater;
 
       act(() => firstUpdater(count => count + 10));
-      expect(Scheduler).toHaveYielded(['Count: 11']);
+      assertLog(['Count: 11']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 11" />);
 
       expect(firstUpdater).toBe(secondUpdater);
     });
 
-    it('does not warn on set after unmount', () => {
+    it('does not warn on set after unmount', async () => {
       let _updateCount;
       function Counter(props, ref) {
         const [, updateCount] = useState(0);
@@ -366,13 +378,13 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushWithoutYielding();
+      await waitForAll([]);
       ReactNoop.render(null);
-      expect(Scheduler).toFlushWithoutYielding();
+      await waitForAll([]);
       act(() => _updateCount(1));
     });
 
-    it('works with memo', () => {
+    it('works with memo', async () => {
       let _updateCount;
       function Counter(props) {
         const [count, updateCount] = useState(0);
@@ -382,21 +394,21 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = memo(Counter);
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield([]);
+      await waitForAll([]);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       act(() => _updateCount(1));
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
     });
   });
 
   describe('updates during the render phase', () => {
-    it('restarts the render function and applies the new updates on top', () => {
+    it('restarts the render function and applies the new updates on top', async () => {
       function ScrollView({row: newRow}) {
         const [isScrollingDown, setIsScrollingDown] = useState(false);
         const [row, setRow] = useState(null);
@@ -411,37 +423,37 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<ScrollView row={1} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: false']);
+      await waitForAll(['Scrolling down: false']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: false" />,
       );
 
       ReactNoop.render(<ScrollView row={5} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: true']);
+      await waitForAll(['Scrolling down: true']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: true" />,
       );
 
       ReactNoop.render(<ScrollView row={5} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: true']);
+      await waitForAll(['Scrolling down: true']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: true" />,
       );
 
       ReactNoop.render(<ScrollView row={10} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: true']);
+      await waitForAll(['Scrolling down: true']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: true" />,
       );
 
       ReactNoop.render(<ScrollView row={2} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: false']);
+      await waitForAll(['Scrolling down: false']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: false" />,
       );
 
       ReactNoop.render(<ScrollView row={2} />);
-      expect(Scheduler).toFlushAndYield(['Scrolling down: false']);
+      await waitForAll(['Scrolling down: false']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Scrolling down: false" />,
       );
@@ -472,7 +484,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
         );
       });
-      expect(Scheduler).toHaveYielded(['Foo [0]', 'Bar']);
+      assertLog(['Foo [0]', 'Bar']);
 
       // Bar will update Foo during its render phase. React should warn.
       await act(async () => {
@@ -498,11 +510,11 @@ describe('ReactHooksWithNoopRenderer', () => {
             <Bar triggerUpdate={true} />
           </>,
         );
-        expect(Scheduler).toFlushAndYield(['Foo [1]', 'Bar', 'Foo [2]']);
+        await waitForAll(['Foo [1]', 'Bar', 'Foo [2]']);
       });
     });
 
-    it('keeps restarting until there are no more new updates', () => {
+    it('keeps restarting until there are no more new updates', async () => {
       function Counter({row: newRow}) {
         const [count, setCount] = useState(0);
         if (count < 3) {
@@ -513,17 +525,11 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield([
-        'Render: 0',
-        'Render: 1',
-        'Render: 2',
-        'Render: 3',
-        3,
-      ]);
+      await waitForAll(['Render: 0', 'Render: 1', 'Render: 2', 'Render: 3', 3]);
       expect(ReactNoop).toMatchRenderedOutput(<span prop={3} />);
     });
 
-    it('updates multiple times within same render function', () => {
+    it('updates multiple times within same render function', async () => {
       function Counter({row: newRow}) {
         const [count, setCount] = useState(0);
         if (count < 12) {
@@ -536,7 +542,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Should increase by three each time
         'Render: 0',
         'Render: 3',
@@ -548,7 +554,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       expect(ReactNoop).toMatchRenderedOutput(<span prop={12} />);
     });
 
-    it('throws after too many iterations', () => {
+    it('throws after too many iterations', async () => {
       function Counter({row: newRow}) {
         const [count, setCount] = useState(0);
         setCount(count + 1);
@@ -562,7 +568,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
     });
 
-    it('works with useReducer', () => {
+    it('works with useReducer', async () => {
       function reducer(state, action) {
         return action === 'increment' ? state + 1 : state;
       }
@@ -576,17 +582,11 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<Counter />);
-      expect(Scheduler).toFlushAndYield([
-        'Render: 0',
-        'Render: 1',
-        'Render: 2',
-        'Render: 3',
-        3,
-      ]);
+      await waitForAll(['Render: 0', 'Render: 1', 'Render: 2', 'Render: 3', 3]);
       expect(ReactNoop).toMatchRenderedOutput(<span prop={3} />);
     });
 
-    it('uses reducer passed at time of render, not time of dispatch', () => {
+    it('uses reducer passed at time of render, not time of dispatch', async () => {
       // This test is a bit contrived but it demonstrates a subtle edge case.
 
       // Reducer A increments by 1. Reducer B increments by 10.
@@ -626,7 +626,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // The count should increase by alternating amounts of 10 and 1
         // until we reach 21.
         'Render: 0',
@@ -643,7 +643,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         counter.current.dispatch('reset');
       });
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Render: 0',
         'Render: 1',
         'Render: 11',
@@ -686,20 +686,20 @@ describe('ReactHooksWithNoopRenderer', () => {
       const root = ReactNoop.createRoot();
       root.render(<Foo signal={true} />);
 
-      expect(Scheduler).toFlushAndYield([0]);
+      await waitForAll([0]);
       expect(root).toMatchRenderedOutput(<span prop={0} />);
 
       React.startTransition(() => {
         root.render(<Foo signal={false} />);
       });
-      expect(Scheduler).toFlushAndYield(['Suspend!']);
+      await waitForAll(['Suspend!']);
       expect(root).toMatchRenderedOutput(<span prop={0} />);
 
       // Rendering again should suspend again.
       React.startTransition(() => {
         root.render(<Foo signal={false} />);
       });
-      expect(Scheduler).toFlushAndYield(['Suspend!']);
+      await waitForAll(['Suspend!']);
     });
 
     it('discards render phase updates if something suspends, but not other updates in the same component', async () => {
@@ -740,7 +740,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       const root = ReactNoop.createRoot();
       root.render(<Foo signal={true} />);
 
-      expect(Scheduler).toFlushAndYield(['A:0']);
+      await waitForAll(['A:0']);
       expect(root).toMatchRenderedOutput(<span prop="A:0" />);
 
       await act(async () => {
@@ -749,21 +749,21 @@ describe('ReactHooksWithNoopRenderer', () => {
           setLabel('B');
         });
 
-        expect(Scheduler).toFlushAndYield(['Suspend!']);
+        await waitForAll(['Suspend!']);
         expect(root).toMatchRenderedOutput(<span prop="A:0" />);
 
         // Rendering again should suspend again.
         React.startTransition(() => {
           root.render(<Foo signal={false} />);
         });
-        expect(Scheduler).toFlushAndYield(['Suspend!']);
+        await waitForAll(['Suspend!']);
 
         // Flip the signal back to "cancel" the update. However, the update to
         // label should still proceed. It shouldn't have been dropped.
         React.startTransition(() => {
           root.render(<Foo signal={true} />);
         });
-        expect(Scheduler).toFlushAndYield(['B:0']);
+        await waitForAll(['B:0']);
         expect(root).toMatchRenderedOutput(<span prop="B:0" />);
       });
     });
@@ -790,7 +790,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       await act(async () => {
         root.render(<ScrollView row={10} />);
       });
-      expect(Scheduler).toHaveYielded(['Up']);
+      assertLog(['Up']);
       expect(root).toMatchRenderedOutput(<span prop="Up" />);
 
       await act(async () => {
@@ -801,7 +801,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           setRow(20);
         });
       });
-      expect(Scheduler).toHaveYielded(['Up', 'Down']);
+      assertLog(['Up', 'Down']);
       expect(root).toMatchRenderedOutput(<span prop="Down" />);
     });
 
@@ -821,13 +821,13 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       const root = ReactNoop.createRoot();
       root.render(<App />);
-      expect(Scheduler).toFlushAndYield([1]);
+      await waitForAll([1]);
       expect(root).toMatchRenderedOutput(<span prop={1} />);
     });
   });
 
   describe('useReducer', () => {
-    it('simple mount and update', () => {
+    it('simple mount and update', async () => {
       const INCREMENT = 'INCREMENT';
       const DECREMENT = 'DECREMENT';
 
@@ -850,11 +850,11 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       act(() => counter.current.dispatch(INCREMENT));
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       act(() => {
         counter.current.dispatch(DECREMENT);
@@ -862,11 +862,11 @@ describe('ReactHooksWithNoopRenderer', () => {
         counter.current.dispatch(DECREMENT);
       });
 
-      expect(Scheduler).toHaveYielded(['Count: -2']);
+      assertLog(['Count: -2']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: -2" />);
     });
 
-    it('lazy init', () => {
+    it('lazy init', async () => {
       const INCREMENT = 'INCREMENT';
       const DECREMENT = 'DECREMENT';
 
@@ -892,11 +892,11 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter initialCount={10} ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Init', 'Count: 10']);
+      await waitForAll(['Init', 'Count: 10']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 10" />);
 
       act(() => counter.current.dispatch(INCREMENT));
-      expect(Scheduler).toHaveYielded(['Count: 11']);
+      assertLog(['Count: 11']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 11" />);
 
       act(() => {
@@ -905,12 +905,12 @@ describe('ReactHooksWithNoopRenderer', () => {
         counter.current.dispatch(DECREMENT);
       });
 
-      expect(Scheduler).toHaveYielded(['Count: 8']);
+      assertLog(['Count: 8']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 8" />);
     });
 
     // Regression test for https://github.com/facebook/react/issues/14360
-    it('handles dispatches with mixed priorities', () => {
+    it('handles dispatches with mixed priorities', async () => {
       const INCREMENT = 'INCREMENT';
 
       function reducer(state, action) {
@@ -927,7 +927,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
 
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       ReactNoop.batchedUpdates(() => {
@@ -940,47 +940,47 @@ describe('ReactHooksWithNoopRenderer', () => {
         counter.current.dispatch(INCREMENT);
       });
       if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(Scheduler).toHaveYielded(['Count: 4']);
+        assertLog(['Count: 4']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 4" />);
       } else {
-        expect(Scheduler).toHaveYielded(['Count: 1']);
+        assertLog(['Count: 1']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
-        expect(Scheduler).toFlushAndYield(['Count: 4']);
+        await waitForAll(['Count: 4']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 4" />);
       }
     });
   });
 
   describe('useEffect', () => {
-    it('simple mount and update', () => {
+    it('simple mount and update', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Passive effect [${props.count}]`);
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
         // Effects are deferred until after the commit
-        expect(Scheduler).toFlushAndYield(['Passive effect [0]']);
+        await waitForAll(['Passive effect [0]']);
       });
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
         // Effects are deferred until after the commit
-        expect(Scheduler).toFlushAndYield(['Passive effect [1]']);
+        await waitForAll(['Passive effect [1]']);
       });
     });
 
-    it('flushes passive effects even with sibling deletions', () => {
+    it('flushes passive effects even with sibling deletions', async () => {
       function LayoutEffect(props) {
         useLayoutEffect(() => {
           Scheduler.unstable_yieldValue(`Layout effect`);
@@ -994,13 +994,9 @@ describe('ReactHooksWithNoopRenderer', () => {
         return <Text text="Passive" />;
       }
       const passive = <PassiveEffect key="p" />;
-      act(() => {
+      await act(async () => {
         ReactNoop.render([<LayoutEffect key="l" />, passive]);
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Layout',
-          'Passive',
-          'Layout effect',
-        ]);
+        await waitFor(['Layout', 'Passive', 'Layout effect']);
         expect(ReactNoop).toMatchRenderedOutput(
           <>
             <span prop="Layout" />
@@ -1010,14 +1006,14 @@ describe('ReactHooksWithNoopRenderer', () => {
         // Destroying the first child shouldn't prevent the passive effect from
         // being executed
         ReactNoop.render([passive]);
-        expect(Scheduler).toFlushAndYield(['Passive effect']);
+        await waitForAll(['Passive effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Passive" />);
       });
       // exiting act calls flushPassiveEffects(), but there are none left to flush.
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
     });
 
-    it('flushes passive effects even if siblings schedule an update', () => {
+    it('flushes passive effects even if siblings schedule an update', async () => {
       function PassiveEffect(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue('Passive effect');
@@ -1038,8 +1034,8 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       ReactNoop.render([<PassiveEffect key="p" />, <LayoutEffect key="l" />]);
 
-      act(() => {
-        expect(Scheduler).toFlushAndYield([
+      await act(async () => {
+        await waitForAll([
           'Passive',
           'Layout',
           'Layout effect 0',
@@ -1057,7 +1053,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
     });
 
-    it('flushes passive effects even if siblings schedule a new root', () => {
+    it('flushes passive effects even if siblings schedule a new root', async () => {
       function PassiveEffect(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue('Passive effect');
@@ -1072,9 +1068,9 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text="Layout" />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render([<PassiveEffect key="p" />, <LayoutEffect key="l" />]);
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           'Passive',
           'Layout',
           'Layout effect',
@@ -1093,7 +1089,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     it(
       'flushes effects serially by flushing old effects before flushing ' +
         "new ones, if they haven't already fired",
-      () => {
+      async () => {
         function getCommittedText() {
           const children = ReactNoop.getChildrenAsJSX();
           if (children === null) {
@@ -1110,17 +1106,17 @@ describe('ReactHooksWithNoopRenderer', () => {
           });
           return <Text text={props.count} />;
         }
-        act(() => {
+        await act(async () => {
           ReactNoop.render(<Counter count={0} />, () =>
             Scheduler.unstable_yieldValue('Sync effect'),
           );
-          expect(Scheduler).toFlushAndYieldThrough([0, 'Sync effect']);
+          await waitFor([0, 'Sync effect']);
           expect(ReactNoop).toMatchRenderedOutput(<span prop={0} />);
           // Before the effects have a chance to flush, schedule another update
           ReactNoop.render(<Counter count={1} />, () =>
             Scheduler.unstable_yieldValue('Sync effect'),
           );
-          expect(Scheduler).toFlushAndYieldThrough([
+          await waitFor([
             // The previous effect flushes before the reconciliation
             'Committed state when effect was fired: 0',
             1,
@@ -1129,13 +1125,11 @@ describe('ReactHooksWithNoopRenderer', () => {
           expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
         });
 
-        expect(Scheduler).toHaveYielded([
-          'Committed state when effect was fired: 1',
-        ]);
+        assertLog(['Committed state when effect was fired: 1']);
       },
     );
 
-    it('defers passive effect destroy functions during unmount', () => {
+    it('defers passive effect destroy functions during unmount', async () => {
       function Child({bar, foo}) {
         React.useEffect(() => {
           Scheduler.unstable_yieldValue('passive bar create');
@@ -1165,61 +1159,52 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Child bar={1} foo={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'render',
           'layout bar create',
           'layout foo create',
           'Sync effect',
         ]);
         // Effects are deferred until after the commit
-        expect(Scheduler).toFlushAndYield([
-          'passive bar create',
-          'passive foo create',
-        ]);
+        await waitForAll(['passive bar create', 'passive foo create']);
       });
 
       // This update exists to test an internal implementation detail:
       // Effects without updating dependencies lose their layout/passive tag during an update.
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Child bar={1} foo={2} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'render',
           'layout foo destroy',
           'layout foo create',
           'Sync effect',
         ]);
         // Effects are deferred until after the commit
-        expect(Scheduler).toFlushAndYield([
-          'passive foo destroy',
-          'passive foo create',
-        ]);
+        await waitForAll(['passive foo destroy', 'passive foo create']);
       });
 
       // Unmount the component and verify that passive destroy functions are deferred until post-commit.
-      act(() => {
+      await act(async () => {
         ReactNoop.render(null, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'layout bar destroy',
           'layout foo destroy',
           'Sync effect',
         ]);
         // Effects are deferred until after the commit
-        expect(Scheduler).toFlushAndYield([
-          'passive bar destroy',
-          'passive foo destroy',
-        ]);
+        await waitForAll(['passive bar destroy', 'passive foo destroy']);
       });
     });
 
-    it('does not warn about state updates for unmounted components with pending passive unmounts', () => {
+    it('does not warn about state updates for unmounted components with pending passive unmounts', async () => {
       let completePendingRequest = null;
       function Component() {
         Scheduler.unstable_yieldValue('Component');
@@ -1241,32 +1226,28 @@ describe('ReactHooksWithNoopRenderer', () => {
         return didLoad;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(<Component />, 'root', () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Component',
-          'layout create',
-          'Sync effect',
-        ]);
+        await waitFor(['Component', 'layout create', 'Sync effect']);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['passive create']);
+        assertLog(['passive create']);
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYieldThrough(['layout destroy']);
+        await waitFor(['layout destroy']);
 
         // Simulate an XHR completing, which will cause a state update-
         // but should not log a warning.
         completePendingRequest();
 
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['passive destroy']);
+        assertLog(['passive destroy']);
       });
     });
 
-    it('does not warn about state updates for unmounted components with pending passive unmounts for alternates', () => {
+    it('does not warn about state updates for unmounted components with pending passive unmounts for alternates', async () => {
       let setParentState = null;
       const setChildStates = [];
 
@@ -1309,9 +1290,9 @@ describe('ReactHooksWithNoopRenderer', () => {
       // later tick: schedule unmount for parent
       // start process unmount (but don't flush passive effectS)
       // State update on child
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Parent />);
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'Parent true render',
           'Child one render',
           'Child two render',
@@ -1324,7 +1305,7 @@ describe('ReactHooksWithNoopRenderer', () => {
 
         // Update children.
         setChildStates.forEach(setChildState => setChildState(1));
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'Child one render',
           'Child two render',
           'Child one commit',
@@ -1335,27 +1316,24 @@ describe('ReactHooksWithNoopRenderer', () => {
         React.startTransition(() => {
           setChildStates.forEach(setChildState => setChildState(2));
         });
-        expect(Scheduler).toFlushAndYieldThrough(['Child one render']);
+        await waitFor(['Child one render']);
 
         // Schedule unmount for the parent that unmounts children with pending update.
         ReactNoop.unstable_runWithPriority(ContinuousEventPriority, () => {
           setParentState(false);
         });
-        expect(Scheduler).toFlushUntilNextPaint([
-          'Parent false render',
-          'Parent false commit',
-        ]);
+        await waitForPaint(['Parent false render', 'Parent false commit']);
 
         // Schedule updates for children too (which should be ignored)
         setChildStates.forEach(setChildState => setChildState(2));
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           'Child one passive destroy',
           'Child two passive destroy',
         ]);
       });
     });
 
-    it('does not warn about state updates for unmounted components with no pending passive unmounts', () => {
+    it('does not warn about state updates for unmounted components with no pending passive unmounts', async () => {
       let completePendingRequest = null;
       function Component() {
         Scheduler.unstable_yieldValue('Component');
@@ -1371,26 +1349,22 @@ describe('ReactHooksWithNoopRenderer', () => {
         return didLoad;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(<Component />, 'root', () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Component',
-          'layout create',
-          'Sync effect',
-        ]);
+        await waitFor(['Component', 'layout create', 'Sync effect']);
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYieldThrough(['layout destroy']);
+        await waitFor(['layout destroy']);
 
         // Simulate an XHR completing.
         completePendingRequest();
       });
     });
 
-    it('does not warn if there are pending passive unmount effects but not for the current fiber', () => {
+    it('does not warn if there are pending passive unmount effects but not for the current fiber', async () => {
       let completePendingRequest = null;
       function ComponentWithXHR() {
         Scheduler.unstable_yieldValue('Component');
@@ -1419,7 +1393,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(
           <>
             <ComponentWithXHR />
@@ -1428,27 +1402,20 @@ describe('ReactHooksWithNoopRenderer', () => {
           'root',
           () => Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Component',
-          'a:layout create',
-          'Sync effect',
-        ]);
+        await waitFor(['Component', 'a:layout create', 'Sync effect']);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded([
-          'a:passive create',
-          'b:passive create',
-        ]);
+        assertLog(['a:passive create', 'b:passive create']);
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYieldThrough(['a:layout destroy']);
+        await waitFor(['a:layout destroy']);
 
         // Simulate an XHR completing in the component without a pending passive effect..
         completePendingRequest();
       });
     });
 
-    it('does not warn if there are updates after pending passive unmount effects have been flushed', () => {
+    it('does not warn if there are updates after pending passive unmount effects have been flushed', async () => {
       let updaterFunction;
 
       function Component() {
@@ -1469,21 +1436,17 @@ describe('ReactHooksWithNoopRenderer', () => {
           Scheduler.unstable_yieldValue('Sync effect'),
         );
       });
-      expect(Scheduler).toHaveYielded([
-        'Component',
-        'Sync effect',
-        'passive create',
-      ]);
+      assertLog(['Component', 'Sync effect', 'passive create']);
 
       ReactNoop.unmountRootWithID('root');
-      expect(Scheduler).toFlushAndYield(['passive destroy']);
+      await waitForAll(['passive destroy']);
 
       act(() => {
         updaterFunction(true);
       });
     });
 
-    it('does not show a warning when a component updates its own state from within passive unmount function', () => {
+    it('does not show a warning when a component updates its own state from within passive unmount function', async () => {
       function Component() {
         Scheduler.unstable_yieldValue('Component');
         const [didLoad, setDidLoad] = React.useState(false);
@@ -1497,23 +1460,19 @@ describe('ReactHooksWithNoopRenderer', () => {
         return didLoad;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(<Component />, 'root', () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Component',
-          'Sync effect',
-          'passive create',
-        ]);
+        await waitFor(['Component', 'Sync effect', 'passive create']);
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYield(['passive destroy']);
+        await waitForAll(['passive destroy']);
       });
     });
 
-    it('does not show a warning when a component updates a child state from within passive unmount function', () => {
+    it('does not show a warning when a component updates a child state from within passive unmount function', async () => {
       function Parent() {
         Scheduler.unstable_yieldValue('Parent');
         const updaterRef = useRef(null);
@@ -1537,9 +1496,9 @@ describe('ReactHooksWithNoopRenderer', () => {
         return state;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(<Parent />, 'root');
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'Parent',
           'Child',
           'Child passive create',
@@ -1548,11 +1507,11 @@ describe('ReactHooksWithNoopRenderer', () => {
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYield(['Parent passive destroy']);
+        await waitForAll(['Parent passive destroy']);
       });
     });
 
-    it('does not show a warning when a component updates a parents state from within passive unmount function', () => {
+    it('does not show a warning when a component updates a parents state from within passive unmount function', async () => {
       function Parent() {
         const [state, setState] = React.useState(false);
         Scheduler.unstable_yieldValue('Parent');
@@ -1571,21 +1530,17 @@ describe('ReactHooksWithNoopRenderer', () => {
         return state;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.renderToRootWithID(<Parent />, 'root');
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Parent',
-          'Child',
-          'Child passive create',
-        ]);
+        await waitFor(['Parent', 'Child', 'Child passive create']);
 
         // Unmount but don't process pending passive destroy function
         ReactNoop.unmountRootWithID('root');
-        expect(Scheduler).toFlushAndYield(['Child passive destroy']);
+        await waitForAll(['Child passive destroy']);
       });
     });
 
-    it('updates have async priority', () => {
+    it('updates have async priority', async () => {
       function Counter(props) {
         const [count, updateCount] = useState('(empty)');
         useEffect(() => {
@@ -1594,33 +1549,30 @@ describe('ReactHooksWithNoopRenderer', () => {
         }, [props.count]);
         return <Text text={'Count: ' + count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Count: (empty)',
-          'Sync effect',
-        ]);
+        await waitFor(['Count: (empty)', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: (empty)" />);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['Schedule update [0]']);
-        expect(Scheduler).toFlushAndYield(['Count: 0']);
+        assertLog(['Schedule update [0]']);
+        await waitForAll(['Count: 0']);
       });
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['Schedule update [1]']);
-        expect(Scheduler).toFlushAndYield(['Count: 1']);
+        assertLog(['Schedule update [1]']);
+        await waitForAll(['Count: 1']);
       });
     });
 
-    it('updates have async priority even if effects are flushed early', () => {
+    it('updates have async priority even if effects are flushed early', async () => {
       function Counter(props) {
         const [count, updateCount] = useState('(empty)');
         useEffect(() => {
@@ -1629,14 +1581,11 @@ describe('ReactHooksWithNoopRenderer', () => {
         }, [props.count]);
         return <Text text={'Count: ' + count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Count: (empty)',
-          'Sync effect',
-        ]);
+        await waitFor(['Count: (empty)', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: (empty)" />);
 
         // Rendering again should flush the previous commit's effects
@@ -1646,13 +1595,10 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Schedule update [0]',
-          'Count: 0',
-        ]);
+        await waitFor(['Schedule update [0]', 'Count: 0']);
 
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'Count: 0',
           'Sync effect',
           'Schedule update [1]',
@@ -1663,7 +1609,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
     });
 
-    it('does not flush non-discrete passive effects when flushing sync', () => {
+    it('does not flush non-discrete passive effects when flushing sync', async () => {
       let _updateCount;
       function Counter(props) {
         const [count, updateCount] = useState(0);
@@ -1678,7 +1624,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       ReactNoop.render(<Counter count={0} />, () =>
         Scheduler.unstable_yieldValue('Sync effect'),
       );
-      expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+      await waitFor(['Count: 0', 'Sync effect']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       // A flush sync doesn't cause the passive effects to fire.
       // So we haven't added the other update yet.
@@ -1692,13 +1638,9 @@ describe('ReactHooksWithNoopRenderer', () => {
       // This should be fine because any non-discrete set of work doesn't guarantee order
       // and easily could've happened slightly later too.
       if (gate(flags => flags.enableUnifiedSyncLane)) {
-        expect(Scheduler).toHaveYielded(['Will set count to 1', 'Count: 1']);
+        assertLog(['Will set count to 1', 'Count: 1']);
       } else {
-        expect(Scheduler).toHaveYielded([
-          'Will set count to 1',
-          'Count: 2',
-          'Count: 1',
-        ]);
+        assertLog(['Will set count to 1', 'Count: 2', 'Count: 1']);
       }
 
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
@@ -1728,7 +1670,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           });
 
           // Even in legacy mode, effects are deferred until after paint
-          expect(Scheduler).toHaveYielded(['Count: (empty)']);
+          assertLog(['Count: (empty)']);
           expect(ReactNoop).toMatchRenderedOutput(
             <span prop="Count: (empty)" />,
           );
@@ -1737,12 +1679,12 @@ describe('ReactHooksWithNoopRenderer', () => {
         // effects get forced on exiting act()
         // There were multiple updates, but there should only be a
         // single render
-        expect(Scheduler).toHaveYielded(['Count: 0']);
+        assertLog(['Count: 0']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       },
     );
 
-    it('flushSync is not allowed', () => {
+    it('flushSync is not allowed', async () => {
       function Counter(props) {
         const [count, updateCount] = useState('(empty)');
         useEffect(() => {
@@ -1750,7 +1692,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           ReactNoop.flushSync(() => {
             updateCount(props.count);
           });
-          expect(Scheduler).toHaveYielded([`Schedule update [${props.count}]`]);
+          assertLog([`Schedule update [${props.count}]`]);
           // This shouldn't flush synchronously.
           expect(ReactNoop).not.toMatchRenderedOutput(
             <span prop={`Count: ${props.count}`} />,
@@ -1758,25 +1700,22 @@ describe('ReactHooksWithNoopRenderer', () => {
         }, [props.count]);
         return <Text text={'Count: ' + count} />;
       }
-      expect(() => {
-        act(() => {
+      await expect(async () => {
+        await act(async () => {
           ReactNoop.render(<Counter count={0} />, () =>
             Scheduler.unstable_yieldValue('Sync effect'),
           );
-          expect(Scheduler).toFlushAndYieldThrough([
-            'Count: (empty)',
-            'Sync effect',
-          ]);
+          await waitFor(['Count: (empty)', 'Sync effect']);
           expect(ReactNoop).toMatchRenderedOutput(
             <span prop="Count: (empty)" />,
           );
         });
       }).toErrorDev('flushSync was called from inside a lifecycle method');
-      expect(Scheduler).toHaveYielded([`Count: 0`]);
+      assertLog([`Count: 0`]);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
     });
 
-    it('unmounts previous effect', () => {
+    it('unmounts previous effect', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Did create [${props.count}]`);
@@ -1786,28 +1725,28 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did create [0]']);
+      assertLog(['Did create [0]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did destroy [0]', 'Did create [1]']);
+      assertLog(['Did destroy [0]', 'Did create [1]']);
     });
 
-    it('unmounts on deletion', () => {
+    it('unmounts on deletion', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Did create [${props.count}]`);
@@ -1817,22 +1756,22 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did create [0]']);
+      assertLog(['Did create [0]']);
 
       ReactNoop.render(null);
-      expect(Scheduler).toFlushAndYield(['Did destroy [0]']);
+      await waitForAll(['Did destroy [0]']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
-    it('unmounts on deletion after skipped effect', () => {
+    it('unmounts on deletion after skipped effect', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Did create [${props.count}]`);
@@ -1842,32 +1781,32 @@ describe('ReactHooksWithNoopRenderer', () => {
         }, []);
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did create [0]']);
+      assertLog(['Did create [0]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
 
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
 
       ReactNoop.render(null);
-      expect(Scheduler).toFlushAndYield(['Did destroy [0]']);
+      await waitForAll(['Did destroy [0]']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
-    it('always fires effects if no dependencies are provided', () => {
+    it('always fires effects if no dependencies are provided', async () => {
       function effect() {
         Scheduler.unstable_yieldValue(`Did create`);
         return () => {
@@ -1878,32 +1817,32 @@ describe('ReactHooksWithNoopRenderer', () => {
         useEffect(effect);
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did create']);
+      assertLog(['Did create']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did destroy', 'Did create']);
+      assertLog(['Did destroy', 'Did create']);
 
       ReactNoop.render(null);
-      expect(Scheduler).toFlushAndYield(['Did destroy']);
+      await waitForAll(['Did destroy']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
-    it('skips effect if inputs have not changed', () => {
+    it('skips effect if inputs have not changed', async () => {
       function Counter(props) {
         const text = `${props.label}: ${props.count}`;
         useEffect(() => {
@@ -1914,57 +1853,51 @@ describe('ReactHooksWithNoopRenderer', () => {
         }, [props.label, props.count]);
         return <Text text={text} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter label="Count" count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
       });
 
-      expect(Scheduler).toHaveYielded(['Did create [Count: 0]']);
+      assertLog(['Did create [Count: 0]']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter label="Count" count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
         // Count changed
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
 
-      expect(Scheduler).toHaveYielded([
-        'Did destroy [Count: 0]',
-        'Did create [Count: 1]',
-      ]);
+      assertLog(['Did destroy [Count: 0]', 'Did create [Count: 1]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter label="Count" count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
         // Nothing changed, so no effect should have fired
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
       });
 
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter label="Total" count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
         // Label changed
-        expect(Scheduler).toFlushAndYieldThrough(['Total: 1', 'Sync effect']);
+        await waitFor(['Total: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Total: 1" />);
       });
 
-      expect(Scheduler).toHaveYielded([
-        'Did destroy [Count: 1]',
-        'Did create [Total: 1]',
-      ]);
+      assertLog(['Did destroy [Count: 1]', 'Did create [Total: 1]']);
     });
 
-    it('multiple effects', () => {
+    it('multiple effects', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Did commit 1 [${props.count}]`);
@@ -1974,27 +1907,27 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Did commit 1 [0]', 'Did commit 2 [0]']);
+      assertLog(['Did commit 1 [0]', 'Did commit 2 [0]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
-      expect(Scheduler).toHaveYielded(['Did commit 1 [1]', 'Did commit 2 [1]']);
+      assertLog(['Did commit 1 [1]', 'Did commit 2 [1]']);
     });
 
-    it('unmounts all previous effects before creating any new ones', () => {
+    it('unmounts all previous effects before creating any new ones', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Mount A [${props.count}]`);
@@ -2010,24 +1943,24 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       });
 
-      expect(Scheduler).toHaveYielded(['Mount A [0]', 'Mount B [0]']);
+      assertLog(['Mount A [0]', 'Mount B [0]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Unmount A [0]',
         'Unmount B [0]',
         'Mount A [1]',
@@ -2035,7 +1968,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       ]);
     });
 
-    it('unmounts all previous effects between siblings before creating any new ones', () => {
+    it('unmounts all previous effects between siblings before creating any new ones', async () => {
       function Counter({count, label}) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Mount ${label} [${count}]`);
@@ -2045,7 +1978,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={`${label} ${count}`} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <>
             <Counter label="A" count={0} />
@@ -2053,7 +1986,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
           () => Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['A 0', 'B 0', 'Sync effect']);
+        await waitFor(['A 0', 'B 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(
           <>
             <span prop="A 0" />
@@ -2062,9 +1995,9 @@ describe('ReactHooksWithNoopRenderer', () => {
         );
       });
 
-      expect(Scheduler).toHaveYielded(['Mount A [0]', 'Mount B [0]']);
+      assertLog(['Mount A [0]', 'Mount B [0]']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <>
             <Counter label="A" count={1} />
@@ -2072,7 +2005,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
           () => Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['A 1', 'B 1', 'Sync effect']);
+        await waitFor(['A 1', 'B 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(
           <>
             <span prop="A 1" />
@@ -2080,14 +2013,14 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
         );
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Unmount A [0]',
         'Unmount B [0]',
         'Mount A [1]',
         'Mount B [1]',
       ]);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <>
             <Counter label="B" count={2} />
@@ -2095,7 +2028,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
           () => Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['B 2', 'C 0', 'Sync effect']);
+        await waitFor(['B 2', 'C 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(
           <>
             <span prop="B 2" />
@@ -2103,7 +2036,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
         );
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Unmount A [1]',
         'Unmount B [1]',
         'Mount B [2]',
@@ -2111,7 +2044,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       ]);
     });
 
-    it('handles errors in create on mount', () => {
+    it('handles errors in create on mount', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Mount A [${props.count}]`);
@@ -2130,16 +2063,16 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
         expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
       });
 
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Mount A [0]',
         'Oops!',
         // Clean up effect A. There's no effect B to clean-up, because it
@@ -2149,7 +2082,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
-    it('handles errors in create on update', () => {
+    it('handles errors in create on update', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Mount A [${props.count}]`);
@@ -2169,40 +2102,35 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return <Text text={'Count: ' + props.count} />;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['Mount A [0]', 'Mount B [0]']);
+        assertLog(['Mount A [0]', 'Mount B [0]']);
       });
 
-      act(() => {
+      await act(async () => {
         // This update will trigger an error
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
         expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
-        expect(Scheduler).toHaveYielded([
-          'Unmount A [0]',
-          'Unmount B [0]',
-          'Mount A [1]',
-          'Oops!',
-        ]);
+        assertLog(['Unmount A [0]', 'Unmount B [0]', 'Mount A [1]', 'Oops!']);
         expect(ReactNoop).toMatchRenderedOutput(null);
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // Clean up effect A runs passively on unmount.
         // There's no effect B to clean-up, because it never mounted.
         'Unmount A [1]',
       ]);
     });
 
-    it('handles errors in destroy on update', () => {
+    it('handles errors in destroy on update', async () => {
       function Counter(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue(`Mount A [${props.count}]`);
@@ -2222,22 +2150,22 @@ describe('ReactHooksWithNoopRenderer', () => {
         return <Text text={'Count: ' + props.count} />;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 0', 'Sync effect']);
+        await waitFor(['Count: 0', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
         ReactNoop.flushPassiveEffects();
-        expect(Scheduler).toHaveYielded(['Mount A [0]', 'Mount B [0]']);
+        assertLog(['Mount A [0]', 'Mount B [0]']);
       });
 
-      act(() => {
+      await act(async () => {
         // This update will trigger an error during passive effect unmount
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Count: 1', 'Sync effect']);
+        await waitFor(['Count: 1', 'Sync effect']);
         expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
         expect(() => ReactNoop.flushPassiveEffects()).toThrow('Oops');
 
@@ -2245,22 +2173,17 @@ describe('ReactHooksWithNoopRenderer', () => {
         // separate pass before flushing any passive creates.
         // A result of this two-pass flush is that an error thrown from unmount does
         // not block the subsequent create functions from being run.
-        expect(Scheduler).toHaveYielded([
-          'Oops!',
-          'Unmount B [0]',
-          'Mount A [1]',
-          'Mount B [1]',
-        ]);
+        assertLog(['Oops!', 'Unmount B [0]', 'Mount A [1]', 'Mount B [1]']);
       });
 
       // <Counter> gets unmounted because an error is thrown above.
       // The remaining destroy functions are run later on unmount, since they're passive.
       // In this case, one of them throws again (because of how the test is written).
-      expect(Scheduler).toHaveYielded(['Oops!', 'Unmount B [1]']);
+      assertLog(['Oops!', 'Unmount B [1]']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
-    it('works with memo', () => {
+    it('works with memo', async () => {
       function Counter({count}) {
         useLayoutEffect(() => {
           Scheduler.unstable_yieldValue('Mount: ' + count);
@@ -2273,26 +2196,17 @@ describe('ReactHooksWithNoopRenderer', () => {
       ReactNoop.render(<Counter count={0} />, () =>
         Scheduler.unstable_yieldValue('Sync effect'),
       );
-      expect(Scheduler).toFlushAndYieldThrough([
-        'Count: 0',
-        'Mount: 0',
-        'Sync effect',
-      ]);
+      await waitFor(['Count: 0', 'Mount: 0', 'Sync effect']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
 
       ReactNoop.render(<Counter count={1} />, () =>
         Scheduler.unstable_yieldValue('Sync effect'),
       );
-      expect(Scheduler).toFlushAndYieldThrough([
-        'Count: 1',
-        'Unmount: 0',
-        'Mount: 1',
-        'Sync effect',
-      ]);
+      await waitFor(['Count: 1', 'Unmount: 0', 'Mount: 1', 'Sync effect']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
 
       ReactNoop.render(null);
-      expect(Scheduler).toFlushAndYieldThrough(['Unmount: 1']);
+      await waitFor(['Unmount: 1']);
       expect(ReactNoop).toMatchRenderedOutput(null);
     });
 
@@ -2351,7 +2265,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
 
       // @gate skipUnmountedBoundaries
-      it('should use the nearest still-mounted boundary if there are no unmounted boundaries', () => {
+      it('should use the nearest still-mounted boundary if there are no unmounted boundaries', async () => {
         act(() => {
           ReactNoop.render(
             <LogOnlyErrorBoundary>
@@ -2360,7 +2274,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'LogOnlyErrorBoundary render',
           'BrokenUseEffectCleanup useEffect',
         ]);
@@ -2369,7 +2283,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           ReactNoop.render(<LogOnlyErrorBoundary />);
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'LogOnlyErrorBoundary render',
           'BrokenUseEffectCleanup useEffect destroy',
           'LogOnlyErrorBoundary componentDidCatch',
@@ -2377,7 +2291,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
 
       // @gate skipUnmountedBoundaries
-      it('should skip unmounted boundaries and use the nearest still-mounted boundary', () => {
+      it('should skip unmounted boundaries and use the nearest still-mounted boundary', async () => {
         function Conditional({showChildren}) {
           if (showChildren) {
             return (
@@ -2398,7 +2312,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'LogOnlyErrorBoundary render',
           'ErrorBoundary render success',
           'BrokenUseEffectCleanup useEffect',
@@ -2412,7 +2326,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'LogOnlyErrorBoundary render',
           'BrokenUseEffectCleanup useEffect destroy',
           'LogOnlyErrorBoundary componentDidCatch',
@@ -2420,7 +2334,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
 
       // @gate skipUnmountedBoundaries
-      it('should call getDerivedStateFromError in the nearest still-mounted boundary', () => {
+      it('should call getDerivedStateFromError in the nearest still-mounted boundary', async () => {
         function Conditional({showChildren}) {
           if (showChildren) {
             return <BrokenUseEffectCleanup />;
@@ -2437,7 +2351,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'ErrorBoundary render success',
           'BrokenUseEffectCleanup useEffect',
         ]);
@@ -2450,7 +2364,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           );
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'ErrorBoundary render success',
           'BrokenUseEffectCleanup useEffect destroy',
           'ErrorBoundary static getDerivedStateFromError',
@@ -2464,7 +2378,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
 
       // @gate skipUnmountedBoundaries
-      it('should rethrow error if there are no still-mounted boundaries', () => {
+      it('should rethrow error if there are no still-mounted boundaries', async () => {
         function Conditional({showChildren}) {
           if (showChildren) {
             return (
@@ -2481,7 +2395,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           ReactNoop.render(<Conditional showChildren={true} />);
         });
 
-        expect(Scheduler).toHaveYielded([
+        assertLog([
           'ErrorBoundary render success',
           'BrokenUseEffectCleanup useEffect',
         ]);
@@ -2492,15 +2406,13 @@ describe('ReactHooksWithNoopRenderer', () => {
           });
         }).toThrow('Expected error');
 
-        expect(Scheduler).toHaveYielded([
-          'BrokenUseEffectCleanup useEffect destroy',
-        ]);
+        assertLog(['BrokenUseEffectCleanup useEffect destroy']);
 
         expect(ReactNoop).toMatchRenderedOutput(null);
       });
     });
 
-    it('calls passive effect destroy functions for memoized components', () => {
+    it('calls passive effect destroy functions for memoized components', async () => {
       const Wrapper = ({children}) => children;
       function Child() {
         React.useEffect(() => {
@@ -2530,11 +2442,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([
-        'render',
-        'layout create',
-        'passive create',
-      ]);
+      assertLog(['render', 'layout create', 'passive create']);
 
       // Include at least one no-op (memoized) update to trigger original bug.
       act(() => {
@@ -2544,7 +2452,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
 
       act(() => {
         ReactNoop.render(
@@ -2553,7 +2461,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'render',
         'layout destroy',
         'layout create',
@@ -2564,10 +2472,10 @@ describe('ReactHooksWithNoopRenderer', () => {
       act(() => {
         ReactNoop.render(null);
       });
-      expect(Scheduler).toHaveYielded(['layout destroy', 'passive destroy']);
+      assertLog(['layout destroy', 'passive destroy']);
     });
 
-    it('calls passive effect destroy functions for descendants of memoized components', () => {
+    it('calls passive effect destroy functions for descendants of memoized components', async () => {
       const Wrapper = ({children}) => children;
       function Child() {
         return <Grandchild />;
@@ -2601,11 +2509,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([
-        'render',
-        'layout create',
-        'passive create',
-      ]);
+      assertLog(['render', 'layout create', 'passive create']);
 
       // Include at least one no-op (memoized) update to trigger original bug.
       act(() => {
@@ -2615,7 +2519,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
 
       act(() => {
         ReactNoop.render(
@@ -2624,7 +2528,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </Wrapper>,
         );
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'render',
         'layout destroy',
         'layout create',
@@ -2635,10 +2539,10 @@ describe('ReactHooksWithNoopRenderer', () => {
       act(() => {
         ReactNoop.render(null);
       });
-      expect(Scheduler).toHaveYielded(['layout destroy', 'passive destroy']);
+      assertLog(['layout destroy', 'passive destroy']);
     });
 
-    it('assumes passive effect destroy function is either a function or undefined', () => {
+    it('assumes passive effect destroy function is either a function or undefined', async () => {
       function App(props) {
         useEffect(() => {
           return props.return;
@@ -2688,7 +2592,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('useInsertionEffect', () => {
-    it('fires insertion effects after snapshots on update', () => {
+    it('fires insertion effects after snapshots on update', async () => {
       function CounterA(props) {
         useInsertionEffect(() => {
           Scheduler.unstable_yieldValue(`Create insertion`);
@@ -2712,7 +2616,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         }
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <>
             <CounterA />
@@ -2720,11 +2624,11 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
         );
 
-        expect(Scheduler).toFlushAndYield(['Create insertion']);
+        await waitForAll(['Create insertion']);
       });
 
       // Update
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <>
             <CounterA />
@@ -2732,7 +2636,7 @@ describe('ReactHooksWithNoopRenderer', () => {
           </>,
         );
 
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           'Get Snapshot',
           'Destroy insertion',
           'Create insertion',
@@ -2740,14 +2644,14 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
 
       // Unmount everything
-      act(() => {
+      await act(async () => {
         ReactNoop.render(null);
 
-        expect(Scheduler).toFlushAndYield(['Destroy insertion']);
+        await waitForAll(['Destroy insertion']);
       });
     });
 
-    it('fires insertion effects before layout effects', () => {
+    it('fires insertion effects before layout effects', async () => {
       let committedText = '(empty)';
 
       function Counter(props) {
@@ -2784,32 +2688,32 @@ describe('ReactHooksWithNoopRenderer', () => {
         });
         return null;
       }
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />);
 
-        expect(Scheduler).toFlushUntilNextPaint([
+        await waitForPaint([
           'Create insertion [current: (empty)]',
           'Create layout [current: 0]',
         ]);
         expect(committedText).toEqual('0');
       });
 
-      expect(Scheduler).toHaveYielded(['Create passive [current: 0]']);
+      assertLog(['Create passive [current: 0]']);
 
       // Unmount everything
-      act(() => {
+      await act(async () => {
         ReactNoop.render(null);
 
-        expect(Scheduler).toFlushUntilNextPaint([
+        await waitForPaint([
           'Destroy insertion [current: 0]',
           'Destroy layout [current: 0]',
         ]);
       });
 
-      expect(Scheduler).toHaveYielded(['Destroy passive [current: 0]']);
+      assertLog(['Destroy passive [current: 0]']);
     });
 
-    it('force flushes passive effects before firing new insertion effects', () => {
+    it('force flushes passive effects before firing new insertion effects', async () => {
       let committedText = '(empty)';
 
       function Counter(props) {
@@ -2848,11 +2752,11 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         React.startTransition(() => {
           ReactNoop.render(<Counter count={0} />);
         });
-        expect(Scheduler).toFlushUntilNextPaint([
+        await waitForPaint([
           'Create insertion [current: (empty)]',
           'Create layout [current: 0]',
         ]);
@@ -2861,7 +2765,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         React.startTransition(() => {
           ReactNoop.render(<Counter count={1} />);
         });
-        expect(Scheduler).toFlushUntilNextPaint([
+        await waitForPaint([
           'Create passive [current: 0]',
           'Destroy insertion [current: 0]',
           'Create insertion [current: 0]',
@@ -2870,13 +2774,13 @@ describe('ReactHooksWithNoopRenderer', () => {
         ]);
         expect(committedText).toEqual('1');
       });
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         'Destroy passive [current: 1]',
         'Create passive [current: 1]',
       ]);
     });
 
-    it('fires all insertion effects (interleaved) before firing any layout effects', () => {
+    it('fires all insertion effects (interleaved) before firing any layout effects', async () => {
       let committedA = '(empty)';
       let committedB = '(empty)';
 
@@ -2976,14 +2880,14 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <React.Fragment>
             <CounterA count={0} />
             <CounterB count={0} />
           </React.Fragment>,
         );
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           // All insertion effects fire before all layout effects
           'Create Insertion 1 for Component A [A: (empty), B: (empty)]',
           'Create Insertion 2 for Component A [A: 0, B: (empty)]',
@@ -2997,14 +2901,14 @@ describe('ReactHooksWithNoopRenderer', () => {
         expect([committedA, committedB]).toEqual(['0', '0']);
       });
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(
           <React.Fragment>
             <CounterA count={1} />
             <CounterB count={1} />
           </React.Fragment>,
         );
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           'Destroy Insertion 1 for Component A [A: 0, B: 0]',
           'Destroy Insertion 2 for Component A [A: 0, B: 0]',
           'Create Insertion 1 for Component A [A: 0, B: 0]',
@@ -3025,10 +2929,10 @@ describe('ReactHooksWithNoopRenderer', () => {
         expect([committedA, committedB]).toEqual(['1', '1']);
 
         // Unmount everything
-        act(() => {
+        await act(async () => {
           ReactNoop.render(null);
 
-          expect(Scheduler).toFlushAndYield([
+          await waitForAll([
             'Destroy Insertion 1 for Component A [A: 1, B: 1]',
             'Destroy Insertion 2 for Component A [A: 1, B: 1]',
             'Destroy Layout 1 for Component A [A: 1, B: 1]',
@@ -3042,7 +2946,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
     });
 
-    it('assumes insertion effect destroy function is either a function or undefined', () => {
+    it('assumes insertion effect destroy function is either a function or undefined', async () => {
       function App(props) {
         useInsertionEffect(() => {
           return props.return;
@@ -3090,7 +2994,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       ).toThrow('is not a function');
     });
 
-    it('warns when setState is called from insertion effect setup', () => {
+    it('warns when setState is called from insertion effect setup', async () => {
       function App(props) {
         const [, setX] = useState(0);
         useInsertionEffect(() => {
@@ -3128,7 +3032,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       });
     });
 
-    it('warns when setState is called from insertion effect cleanup', () => {
+    it('warns when setState is called from insertion effect cleanup', async () => {
       function App(props) {
         const [, setX] = useState(0);
         useInsertionEffect(() => {
@@ -3173,7 +3077,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('useLayoutEffect', () => {
-    it('fires layout effects after the host has been mutated', () => {
+    it('fires layout effects after the host has been mutated', async () => {
       function getCommittedText() {
         const yields = Scheduler.unstable_clearYields();
         const children = ReactNoop.getChildrenAsJSX();
@@ -3194,25 +3098,17 @@ describe('ReactHooksWithNoopRenderer', () => {
       ReactNoop.render(<Counter count={0} />, () =>
         Scheduler.unstable_yieldValue('Sync effect'),
       );
-      expect(Scheduler).toFlushAndYieldThrough([
-        [0],
-        'Current: 0',
-        'Sync effect',
-      ]);
+      await waitFor([[0], 'Current: 0', 'Sync effect']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop={0} />);
 
       ReactNoop.render(<Counter count={1} />, () =>
         Scheduler.unstable_yieldValue('Sync effect'),
       );
-      expect(Scheduler).toFlushAndYieldThrough([
-        [1],
-        'Current: 1',
-        'Sync effect',
-      ]);
+      await waitFor([[1], 'Current: 1', 'Sync effect']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
     });
 
-    it('force flushes passive effects before firing new layout effects', () => {
+    it('force flushes passive effects before firing new layout effects', async () => {
       let committedText = '(empty)';
 
       function Counter(props) {
@@ -3243,19 +3139,16 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<Counter count={0} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
-          'Mount layout [current: 0]',
-          'Sync effect',
-        ]);
+        await waitFor(['Mount layout [current: 0]', 'Sync effect']);
         expect(committedText).toEqual('0');
         ReactNoop.render(<Counter count={1} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough([
+        await waitFor([
           'Mount normal [current: 0]',
           'Unmount layout [current: 0]',
           'Mount layout [current: 1]',
@@ -3264,14 +3157,11 @@ describe('ReactHooksWithNoopRenderer', () => {
         expect(committedText).toEqual('1');
       });
 
-      expect(Scheduler).toHaveYielded([
-        'Unmount normal [current: 1]',
-        'Mount normal [current: 1]',
-      ]);
+      assertLog(['Unmount normal [current: 1]', 'Mount normal [current: 1]']);
     });
 
     // @gate skipUnmountedBoundaries
-    it('catches errors thrown in useLayoutEffect', () => {
+    it('catches errors thrown in useLayoutEffect', async () => {
       class ErrorBoundary extends React.Component {
         state = {error: null};
         static getDerivedStateFromError(error) {
@@ -3320,7 +3210,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         </ErrorBoundary>,
       );
 
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         'OuterBoundary render success',
         'Component render sibling',
         'InnerBoundary render success',
@@ -3340,7 +3230,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
 
       // React should skip over the unmounting boundary and find the nearest still-mounted boundary.
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         'OuterBoundary render success',
         'Component render sibling',
         'BrokenLayoutEffectDestroy useLayoutEffect destroy',
@@ -3351,7 +3241,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       expect(ReactNoop).toMatchRenderedOutput(<span prop="OuterFallback" />);
     });
 
-    it('assumes layout effect destroy function is either a function or undefined', () => {
+    it('assumes layout effect destroy function is either a function or undefined', async () => {
       function App(props) {
         useLayoutEffect(() => {
           return props.return;
@@ -3401,7 +3291,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('useCallback', () => {
-    it('memoizes callback by comparing inputs', () => {
+    it('memoizes callback by comparing inputs', async () => {
       class IncrementButton extends React.PureComponent {
         increment = () => {
           this.props.increment();
@@ -3427,7 +3317,7 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       const button = React.createRef(null);
       ReactNoop.render(<Counter incrementBy={1} />);
-      expect(Scheduler).toFlushAndYield(['Increment', 'Count: 0']);
+      await waitForAll(['Increment', 'Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="Increment" />
@@ -3436,7 +3326,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
 
       act(button.current.increment);
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // Button should not re-render, because its props haven't changed
         // 'Increment',
         'Count: 1',
@@ -3450,7 +3340,7 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       // Increase the increment amount
       ReactNoop.render(<Counter incrementBy={10} />);
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Inputs did change this time
         'Increment',
         'Count: 1',
@@ -3464,7 +3354,7 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       // Callback should have updated
       act(button.current.increment);
-      expect(Scheduler).toHaveYielded(['Count: 11']);
+      assertLog(['Count: 11']);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="Increment" />
@@ -3475,7 +3365,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('useMemo', () => {
-    it('memoizes value by comparing to previous inputs', () => {
+    it('memoizes value by comparing to previous inputs', async () => {
       function CapitalizedText(props) {
         const text = props.text;
         const capitalizedText = useMemo(() => {
@@ -3486,23 +3376,23 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<CapitalizedText text="hello" />);
-      expect(Scheduler).toFlushAndYield(["Capitalize 'hello'", 'HELLO']);
+      await waitForAll(["Capitalize 'hello'", 'HELLO']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="HELLO" />);
 
       ReactNoop.render(<CapitalizedText text="hi" />);
-      expect(Scheduler).toFlushAndYield(["Capitalize 'hi'", 'HI']);
+      await waitForAll(["Capitalize 'hi'", 'HI']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="HI" />);
 
       ReactNoop.render(<CapitalizedText text="hi" />);
-      expect(Scheduler).toFlushAndYield(['HI']);
+      await waitForAll(['HI']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="HI" />);
 
       ReactNoop.render(<CapitalizedText text="goodbye" />);
-      expect(Scheduler).toFlushAndYield(["Capitalize 'goodbye'", 'GOODBYE']);
+      await waitForAll(["Capitalize 'goodbye'", 'GOODBYE']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="GOODBYE" />);
     });
 
-    it('always re-computes if no inputs are provided', () => {
+    it('always re-computes if no inputs are provided', async () => {
       function LazyCompute(props) {
         const computed = useMemo(props.compute);
         return <Text text={computed} />;
@@ -3519,19 +3409,19 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<LazyCompute compute={computeA} />);
-      expect(Scheduler).toFlushAndYield(['compute A', 'A']);
+      await waitForAll(['compute A', 'A']);
 
       ReactNoop.render(<LazyCompute compute={computeA} />);
-      expect(Scheduler).toFlushAndYield(['compute A', 'A']);
+      await waitForAll(['compute A', 'A']);
 
       ReactNoop.render(<LazyCompute compute={computeA} />);
-      expect(Scheduler).toFlushAndYield(['compute A', 'A']);
+      await waitForAll(['compute A', 'A']);
 
       ReactNoop.render(<LazyCompute compute={computeB} />);
-      expect(Scheduler).toFlushAndYield(['compute B', 'B']);
+      await waitForAll(['compute B', 'B']);
     });
 
-    it('should not invoke memoized function during re-renders unless inputs change', () => {
+    it('should not invoke memoized function during re-renders unless inputs change', async () => {
       function LazyCompute(props) {
         const computed = useMemo(
           () => props.compute(props.input),
@@ -3550,18 +3440,18 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<LazyCompute compute={compute} input="A" />);
-      expect(Scheduler).toFlushAndYield(['compute A', 'A']);
+      await waitForAll(['compute A', 'A']);
 
       ReactNoop.render(<LazyCompute compute={compute} input="A" />);
-      expect(Scheduler).toFlushAndYield(['A']);
+      await waitForAll(['A']);
 
       ReactNoop.render(<LazyCompute compute={compute} input="B" />);
-      expect(Scheduler).toFlushAndYield(['compute B', 'B']);
+      await waitForAll(['compute B', 'B']);
     });
   });
 
   describe('useImperativeHandle', () => {
-    it('does not update when deps are the same', () => {
+    it('does not update when deps are the same', async () => {
       const INCREMENT = 'INCREMENT';
 
       function reducer(state, action) {
@@ -3577,21 +3467,21 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       expect(counter.current.count).toBe(0);
 
       act(() => {
         counter.current.dispatch(INCREMENT);
       });
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       // Intentionally not updated because of [] deps:
       expect(counter.current.count).toBe(0);
     });
 
     // Regression test for https://github.com/facebook/react/issues/14782
-    it('automatically updates when deps are not specified', () => {
+    it('automatically updates when deps are not specified', async () => {
       const INCREMENT = 'INCREMENT';
 
       function reducer(state, action) {
@@ -3607,19 +3497,19 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       expect(counter.current.count).toBe(0);
 
       act(() => {
         counter.current.dispatch(INCREMENT);
       });
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       expect(counter.current.count).toBe(1);
     });
 
-    it('updates when deps are different', () => {
+    it('updates when deps are different', async () => {
       const INCREMENT = 'INCREMENT';
 
       function reducer(state, action) {
@@ -3643,7 +3533,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       Counter = forwardRef(Counter);
       const counter = React.createRef(null);
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 0']);
+      await waitForAll(['Count: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 0" />);
       expect(counter.current.count).toBe(0);
       expect(totalRefUpdates).toBe(1);
@@ -3651,14 +3541,14 @@ describe('ReactHooksWithNoopRenderer', () => {
       act(() => {
         counter.current.dispatch(INCREMENT);
       });
-      expect(Scheduler).toHaveYielded(['Count: 1']);
+      assertLog(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       expect(counter.current.count).toBe(1);
       expect(totalRefUpdates).toBe(2);
 
       // Update that doesn't change the ref dependencies
       ReactNoop.render(<Counter ref={counter} />);
-      expect(Scheduler).toFlushAndYield(['Count: 1']);
+      await waitForAll(['Count: 1']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="Count: 1" />);
       expect(counter.current.count).toBe(1);
       expect(totalRefUpdates).toBe(2); // Should not increase since last time
@@ -3688,7 +3578,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         );
       }
       ReactNoop.render(<App />);
-      expect(Scheduler).toFlushAndYield(['Before... Pending: false']);
+      await waitForAll(['Before... Pending: false']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="Before... Pending: false" />,
       );
@@ -3696,7 +3586,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       await act(async () => {
         transition();
 
-        expect(Scheduler).toFlushAndYield([
+        await waitForAll([
           'Before... Pending: true',
           'Suspend! [After... Pending: false]',
           'Loading... Pending: false',
@@ -3715,10 +3605,8 @@ describe('ReactHooksWithNoopRenderer', () => {
         );
 
         await resolveText('After... Pending: false');
-        expect(Scheduler).toHaveYielded([
-          'Promise resolved [After... Pending: false]',
-        ]);
-        expect(Scheduler).toFlushAndYield(['After... Pending: false']);
+        assertLog(['Promise resolved [After... Pending: false]']);
+        await waitForAll(['After... Pending: false']);
         expect(ReactNoop).toMatchRenderedOutput(
           <span prop="After... Pending: false" />,
         );
@@ -3753,7 +3641,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         ReactNoop.render(<App />);
       });
 
-      expect(Scheduler).toHaveYielded(['A', 'Suspend! [A]', 'Loading']);
+      assertLog(['A', 'Suspend! [A]', 'Loading']);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="A" />
@@ -3762,8 +3650,8 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
 
       await resolveText('A');
-      expect(Scheduler).toHaveYielded(['Promise resolved [A]']);
-      expect(Scheduler).toFlushAndYield(['A']);
+      assertLog(['Promise resolved [A]']);
+      await waitForAll(['A']);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="A" />
@@ -3773,14 +3661,8 @@ describe('ReactHooksWithNoopRenderer', () => {
 
       await act(async () => {
         _setText('B');
-        expect(Scheduler).toFlushAndYield([
-          'B',
-          'A',
-          'B',
-          'Suspend! [B]',
-          'Loading',
-        ]);
-        expect(Scheduler).toFlushAndYield([]);
+        await waitForAll(['B', 'A', 'B', 'Suspend! [B]', 'Loading']);
+        await waitForAll([]);
         expect(ReactNoop).toMatchRenderedOutput(
           <>
             <span prop="B" />
@@ -3793,7 +3675,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         Scheduler.unstable_advanceTime(250);
         await advanceTimers(250);
       });
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="B" />
@@ -3804,7 +3686,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       // Even after a long amount of time, we don't show a fallback
       Scheduler.unstable_advanceTime(100000);
       await advanceTimers(100000);
-      expect(Scheduler).toFlushAndYield([]);
+      await waitForAll([]);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="B" />
@@ -3815,7 +3697,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       await act(async () => {
         await resolveText('B');
       });
-      expect(Scheduler).toHaveYielded(['Promise resolved [B]', 'B', 'B']);
+      assertLog(['Promise resolved [B]', 'B', 'B']);
       expect(ReactNoop).toMatchRenderedOutput(
         <>
           <span prop="B" />
@@ -3826,7 +3708,7 @@ describe('ReactHooksWithNoopRenderer', () => {
   });
 
   describe('progressive enhancement (not supported)', () => {
-    it('mount additional state', () => {
+    it('mount additional state', async () => {
       let updateA;
       let updateB;
       // let updateC;
@@ -3848,7 +3730,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<App loadC={false} />);
-      expect(Scheduler).toFlushAndYield(['A: 0, B: 0, C: [not loaded]']);
+      await waitForAll(['A: 0, B: 0, C: [not loaded]']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="A: 0, B: 0, C: [not loaded]" />,
       );
@@ -3858,16 +3740,17 @@ describe('ReactHooksWithNoopRenderer', () => {
         updateB(3);
       });
 
-      expect(Scheduler).toHaveYielded(['A: 2, B: 3, C: [not loaded]']);
+      assertLog(['A: 2, B: 3, C: [not loaded]']);
       expect(ReactNoop).toMatchRenderedOutput(
         <span prop="A: 2, B: 3, C: [not loaded]" />,
       );
 
       ReactNoop.render(<App loadC={true} />);
-      expect(() => {
-        expect(() => {
-          expect(Scheduler).toFlushAndYield(['A: 2, B: 3, C: 0']);
-        }).toThrow('Rendered more hooks than during the previous render');
+      await expect(async () => {
+        await waitForThrow(
+          'Rendered more hooks than during the previous render.',
+        );
+        assertLog([]);
       }).toErrorDev([
         'Warning: React has detected a change in the order of Hooks called by App. ' +
           'This will lead to bugs and errors if not fixed. For more information, ' +
@@ -3888,7 +3771,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       // expect(ReactNoop).toMatchRenderedOutput(<span prop="A: 2, B: 3, C: 4" />]);
     });
 
-    it('unmount state', () => {
+    it('unmount state', async () => {
       let updateA;
       let updateB;
       let updateC;
@@ -3912,14 +3795,14 @@ describe('ReactHooksWithNoopRenderer', () => {
       }
 
       ReactNoop.render(<App loadC={true} />);
-      expect(Scheduler).toFlushAndYield(['A: 0, B: 0, C: 0']);
+      await waitForAll(['A: 0, B: 0, C: 0']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="A: 0, B: 0, C: 0" />);
       act(() => {
         updateA(2);
         updateB(3);
         updateC(4);
       });
-      expect(Scheduler).toHaveYielded(['A: 2, B: 3, C: 4']);
+      assertLog(['A: 2, B: 3, C: 4']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="A: 2, B: 3, C: 4" />);
       ReactNoop.render(<App loadC={false} />);
       expect(Scheduler).toFlushAndThrow(
@@ -3928,7 +3811,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       );
     });
 
-    it('unmount effects', () => {
+    it('unmount effects', async () => {
       function App(props) {
         useEffect(() => {
           Scheduler.unstable_yieldValue('Mount A');
@@ -3949,21 +3832,22 @@ describe('ReactHooksWithNoopRenderer', () => {
         return null;
       }
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<App showMore={false} />, () =>
           Scheduler.unstable_yieldValue('Sync effect'),
         );
-        expect(Scheduler).toFlushAndYieldThrough(['Sync effect']);
+        await waitFor(['Sync effect']);
       });
 
-      expect(Scheduler).toHaveYielded(['Mount A']);
+      assertLog(['Mount A']);
 
-      act(() => {
+      await act(async () => {
         ReactNoop.render(<App showMore={true} />);
-        expect(() => {
-          expect(() => {
-            expect(Scheduler).toFlushAndYield([]);
-          }).toThrow('Rendered more hooks than during the previous render');
+        await expect(async () => {
+          await waitForThrow(
+            'Rendered more hooks than during the previous render.',
+          );
+          assertLog([]);
         }).toErrorDev([
           'Warning: React has detected a change in the order of Hooks called by App. ' +
             'This will lead to bugs and errors if not fixed. For more information, ' +
@@ -3988,7 +3872,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     });
   });
 
-  it('useReducer does not eagerly bail out of state updates', () => {
+  it('useReducer does not eagerly bail out of state updates', async () => {
     // Edge case based on a bug report
     let setCounter;
     function App() {
@@ -4013,30 +3897,20 @@ describe('ReactHooksWithNoopRenderer', () => {
       return count;
     }
 
-    act(() => {
+    await act(async () => {
       ReactNoop.render(<App />);
-      expect(Scheduler).toFlushAndYield([
-        'Render: -1',
-        'Effect: 1',
-        'Reducer: 1',
-        'Render: 1',
-      ]);
+      await waitForAll(['Render: -1', 'Effect: 1', 'Reducer: 1', 'Render: 1']);
       expect(ReactNoop).toMatchRenderedOutput('1');
     });
 
     act(() => {
       setCounter(2);
     });
-    expect(Scheduler).toHaveYielded([
-      'Render: 1',
-      'Effect: 2',
-      'Reducer: 2',
-      'Render: 2',
-    ]);
+    assertLog(['Render: 1', 'Effect: 2', 'Reducer: 2', 'Render: 2']);
     expect(ReactNoop).toMatchRenderedOutput('2');
   });
 
-  it('useReducer does not replay previous no-op actions when other state changes', () => {
+  it('useReducer does not replay previous no-op actions when other state changes', async () => {
     let increment;
     let setDisabled;
 
@@ -4061,10 +3935,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     }
 
     ReactNoop.render(<Counter />);
-    expect(Scheduler).toFlushAndYield([
-      'Render disabled: true',
-      'Render count: 0',
-    ]);
+    await waitForAll(['Render disabled: true', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => {
@@ -4073,24 +3944,18 @@ describe('ReactHooksWithNoopRenderer', () => {
       increment();
       increment();
     });
-    expect(Scheduler).toHaveYielded([
-      'Render disabled: true',
-      'Render count: 0',
-    ]);
+    assertLog(['Render disabled: true', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => {
       // Enabling the updater should *not* replay the previous increment() actions
       setDisabled(false);
     });
-    expect(Scheduler).toHaveYielded([
-      'Render disabled: false',
-      'Render count: 0',
-    ]);
+    assertLog(['Render disabled: false', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
   });
 
-  it('useReducer does not replay previous no-op actions when props change', () => {
+  it('useReducer does not replay previous no-op actions when props change', async () => {
     let setDisabled;
     let increment;
 
@@ -4119,10 +3984,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     }
 
     ReactNoop.render(<App />);
-    expect(Scheduler).toFlushAndYield([
-      'Render disabled: true',
-      'Render count: 0',
-    ]);
+    await waitForAll(['Render disabled: true', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => {
@@ -4131,21 +3993,18 @@ describe('ReactHooksWithNoopRenderer', () => {
       increment();
       increment();
     });
-    expect(Scheduler).toHaveYielded(['Render count: 0']);
+    assertLog(['Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => {
       // Enabling the updater should *not* replay the previous increment() actions
       setDisabled(false);
     });
-    expect(Scheduler).toHaveYielded([
-      'Render disabled: false',
-      'Render count: 0',
-    ]);
+    assertLog(['Render disabled: false', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
   });
 
-  it('useReducer applies potential no-op changes if made relevant by other updates in the batch', () => {
+  it('useReducer applies potential no-op changes if made relevant by other updates in the batch', async () => {
     let setDisabled;
     let increment;
 
@@ -4174,10 +4033,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     }
 
     ReactNoop.render(<App />);
-    expect(Scheduler).toFlushAndYield([
-      'Render disabled: true',
-      'Render count: 0',
-    ]);
+    await waitForAll(['Render disabled: true', 'Render count: 0']);
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => {
@@ -4188,10 +4044,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       increment();
       setDisabled(false);
     });
-    expect(Scheduler).toHaveYielded([
-      'Render disabled: false',
-      'Render count: 1',
-    ]);
+    assertLog(['Render disabled: false', 'Render count: 1']);
     expect(ReactNoop).toMatchRenderedOutput('1');
   });
 
@@ -4230,12 +4083,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded([
-      'Render A: 0',
-      'Render B: 0',
-      'Commit A: 0',
-      'Commit B: 0',
-    ]);
+    assertLog(['Render A: 0', 'Render B: 0', 'Commit A: 0', 'Commit B: 0']);
 
     await act(async () => {
       setCounterA(1);
@@ -4246,7 +4094,7 @@ describe('ReactHooksWithNoopRenderer', () => {
       setCounterB(1);
       setCounterB(0);
     });
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Render A: 1',
       'Render B: 0',
       'Commit A: 1',
@@ -4255,7 +4103,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     ]);
   });
 
-  it('should update latest rendered reducer when a preceding state receives a render phase update', () => {
+  it('should update latest rendered reducer when a preceding state receives a render phase update', async () => {
     // Similar to previous test, except using a preceding render phase update
     // instead of new props.
     let dispatch;
@@ -4273,7 +4121,7 @@ describe('ReactHooksWithNoopRenderer', () => {
     }
 
     ReactNoop.render(<App />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Step: 0, Shadow: 0',
       'Step: 1, Shadow: 0',
       'Step: 2, Shadow: 0',
@@ -4284,11 +4132,11 @@ describe('ReactHooksWithNoopRenderer', () => {
     expect(ReactNoop).toMatchRenderedOutput('0');
 
     act(() => dispatch());
-    expect(Scheduler).toHaveYielded(['Step: 5, Shadow: 5']);
+    assertLog(['Step: 5, Shadow: 5']);
     expect(ReactNoop).toMatchRenderedOutput('5');
   });
 
-  it('should process the rest pending updates after a render phase update', () => {
+  it('should process the rest pending updates after a render phase update', async () => {
     // Similar to previous test, except using a preceding render phase update
     // instead of new props.
     let updateA;
@@ -4346,7 +4194,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Mount layout A',
       'Mount layout B',
       'Mount passive A',
@@ -4362,13 +4210,13 @@ describe('ReactHooksWithNoopRenderer', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded(['Unmount layout A', 'Unmount passive A']);
+    assertLog(['Unmount layout A', 'Unmount passive A']);
 
     // Now delete and unmount B.
     await act(async () => {
       root.render(null);
     });
-    expect(Scheduler).toHaveYielded(['Unmount layout B', 'Unmount passive B']);
+    assertLog(['Unmount layout B', 'Unmount passive B']);
   });
 
   it('regression: deleting a tree and unmounting its effects after a reorder', async () => {
@@ -4392,7 +4240,7 @@ describe('ReactHooksWithNoopRenderer', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded(['Mount A', 'Mount B']);
+    assertLog(['Mount A', 'Mount B']);
 
     await act(async () => {
       root.render(
@@ -4402,13 +4250,13 @@ describe('ReactHooksWithNoopRenderer', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
 
     await act(async () => {
       root.render(null);
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Unmount B',
       // In the regression, the reorder would cause Child A to "forget" that it
       // contains passive effects. Then when we deleted the tree, A's unmount
@@ -4446,21 +4294,12 @@ describe('ReactHooksWithNoopRenderer', () => {
     await act(async () => {
       root.render(<App />);
     });
-    expect(Scheduler).toHaveYielded([
-      'Suspend! [A]',
-      'Suspend! [B]',
-      'Mount A',
-      'Mount B',
-    ]);
+    assertLog(['Suspend! [A]', 'Suspend! [B]', 'Mount A', 'Mount B']);
 
     await act(async () => {
       await resolveText('A');
     });
-    expect(Scheduler).toHaveYielded([
-      'Promise resolved [A]',
-      'A',
-      'Suspend! [B]',
-    ]);
+    assertLog(['Promise resolved [A]', 'A', 'Suspend! [B]']);
 
     await act(async () => {
       root.render(null);
@@ -4468,10 +4307,10 @@ describe('ReactHooksWithNoopRenderer', () => {
     // In the regression, SuspenseList would cause the children to "forget" that
     // it contains passive effects. Then when we deleted the tree, these unmount
     // effects would not fire.
-    expect(Scheduler).toHaveYielded(['Unmount A', 'Unmount B']);
+    assertLog(['Unmount A', 'Unmount B']);
   });
 
-  it('effect dependencies are persisted after a render phase update', () => {
+  it('effect dependencies are persisted after a render phase update', async () => {
     let handleClick;
     function Test() {
       const [count, setCount] = useState(0);
@@ -4493,24 +4332,24 @@ describe('ReactHooksWithNoopRenderer', () => {
       ReactNoop.render(<Test />);
     });
 
-    expect(Scheduler).toHaveYielded(['Render: 0', 'Effect: 0']);
+    assertLog(['Render: 0', 'Effect: 0']);
 
     act(() => {
       handleClick();
     });
 
-    expect(Scheduler).toHaveYielded(['Render: 0']);
+    assertLog(['Render: 0']);
 
     act(() => {
       handleClick();
     });
 
-    expect(Scheduler).toHaveYielded(['Render: 0']);
+    assertLog(['Render: 0']);
 
     act(() => {
       handleClick();
     });
 
-    expect(Scheduler).toHaveYielded(['Render: 0']);
+    assertLog(['Render: 0']);
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncremental-test.js b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
index 21edc33da1711..abf56e32b73ad 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
@@ -14,6 +14,10 @@ let React;
 let ReactNoop;
 let Scheduler;
 let PropTypes;
+let waitForAll;
+let waitFor;
+let waitForThrow;
+let assertLog;
 
 describe('ReactIncremental', () => {
   beforeEach(() => {
@@ -22,6 +26,12 @@ describe('ReactIncremental', () => {
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
     PropTypes = require('prop-types');
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    waitForThrow = InternalTestUtils.waitForThrow;
+    assertLog = InternalTestUtils.assertLog;
   });
 
   // Note: This is based on a similar component we use in www. We can delete
@@ -37,7 +47,7 @@ describe('ReactIncremental', () => {
     );
   }
 
-  it('should render a simple component', () => {
+  it('should render a simple component', async () => {
     function Bar() {
       return <div>Hello World</div>;
     }
@@ -47,10 +57,10 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
   });
 
-  it('should render a simple component, in steps if needed', () => {
+  it('should render a simple component, in steps if needed', async () => {
     function Bar() {
       Scheduler.unstable_yieldValue('Bar');
       return (
@@ -74,10 +84,10 @@ describe('ReactIncremental', () => {
     expect(ReactNoop.flushNextYield()).toEqual(['Foo']);
 
     // Do the rest of the work.
-    expect(Scheduler).toFlushAndYield(['Bar', 'Bar', 'callback']);
+    await waitForAll(['Bar', 'Bar', 'callback']);
   });
 
-  it('updates a previous render', () => {
+  it('updates a previous render', async () => {
     function Header() {
       Scheduler.unstable_yieldValue('Header');
       return <h1>Hi</h1>;
@@ -110,7 +120,7 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo text="foo" />, () =>
       Scheduler.unstable_yieldValue('renderCallbackCalled'),
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Foo',
       'Header',
       'Content',
@@ -128,7 +138,7 @@ describe('ReactIncremental', () => {
 
     // Since this is an update, it should bail out and reuse the work from
     // Header and Content.
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Foo',
       'Content',
       'firstRenderCallbackCalled',
@@ -136,7 +146,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('can cancel partially rendered work and restart', () => {
+  it('can cancel partially rendered work and restart', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -154,13 +164,13 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar']);
 
     React.startTransition(() => {
       ReactNoop.render(<Foo text="bar" />);
     });
     // Flush part of the work
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Bar']);
+    await waitFor(['Foo', 'Bar']);
 
     // This will abort the previous work and restart
     ReactNoop.flushSync(() => ReactNoop.render(null));
@@ -170,13 +180,13 @@ describe('ReactIncremental', () => {
     });
 
     // Flush part of the new work
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Bar']);
+    await waitFor(['Foo', 'Bar']);
 
     // Flush the rest of the work which now includes the low priority
-    expect(Scheduler).toFlushAndYield(['Bar']);
+    await waitForAll(['Bar']);
   });
 
-  it('should call callbacks even if updates are aborted', () => {
+  it('should call callbacks even if updates are aborted', async () => {
     let inst;
 
     class Foo extends React.Component {
@@ -199,7 +209,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     React.startTransition(() => {
       inst.setState(
@@ -212,7 +222,7 @@ describe('ReactIncremental', () => {
     });
 
     // Flush part of the work
-    expect(Scheduler).toFlushAndYieldThrough(['setState1']);
+    await waitFor(['setState1']);
 
     // This will abort the previous work and restart
     ReactNoop.flushSync(() => ReactNoop.render(<Foo />));
@@ -227,17 +237,12 @@ describe('ReactIncremental', () => {
     });
 
     // Flush the rest of the work which now includes the low priority
-    expect(Scheduler).toFlushAndYield([
-      'setState1',
-      'setState2',
-      'callback1',
-      'callback2',
-    ]);
+    await waitForAll(['setState1', 'setState2', 'callback1', 'callback2']);
     expect(inst.state).toEqual({text: 'bar', text2: 'baz'});
   });
 
   // @gate www
-  it('can deprioritize unfinished work and resume it later', () => {
+  it('can deprioritize unfinished work and resume it later', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -266,24 +271,18 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" />);
-    expect(Scheduler).toFlushAndYield([
-      'Foo',
-      'Bar',
-      'Bar',
-      'Middle',
-      'Middle',
-    ]);
+    await waitForAll(['Foo', 'Bar', 'Bar', 'Middle', 'Middle']);
 
     // Render part of the work. This should be enough to flush everything except
     // the middle which has lower priority.
     ReactNoop.render(<Foo text="bar" />);
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Bar', 'Bar']);
+    await waitFor(['Foo', 'Bar', 'Bar']);
     // Flush only the remaining work
-    expect(Scheduler).toFlushAndYield(['Middle', 'Middle']);
+    await waitForAll(['Middle', 'Middle']);
   });
 
   // @gate www
-  it('can deprioritize a tree from without dropping work', () => {
+  it('can deprioritize a tree from without dropping work', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -314,21 +313,21 @@ describe('ReactIncremental', () => {
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Foo text="foo" />);
     });
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Bar']);
-    expect(Scheduler).toFlushAndYield(['Middle', 'Middle']);
+    assertLog(['Foo', 'Bar', 'Bar']);
+    await waitForAll(['Middle', 'Middle']);
 
     // Render the high priority work (everything except the hidden trees).
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Foo text="foo" />);
     });
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Bar']);
+    assertLog(['Foo', 'Bar', 'Bar']);
 
     // The hidden content was deprioritized from high to low priority. A low
     // priority callback should have been scheduled. Flush it now.
-    expect(Scheduler).toFlushAndYield(['Middle', 'Middle']);
+    await waitForAll(['Middle', 'Middle']);
   });
 
-  xit('can resume work in a subtree even when a parent bails out', () => {
+  xit('can resume work in a subtree even when a parent bails out', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -372,19 +371,19 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo text="foo" />);
     ReactNoop.flushDeferredPri(52);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Tester', 'Bar']);
+    assertLog(['Foo', 'Bar', 'Tester', 'Bar']);
 
     // We're now rendering an update that will bail out on updating middle.
     ReactNoop.render(<Foo text="bar" />);
     ReactNoop.flushDeferredPri(45 + 5);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Bar']);
+    assertLog(['Foo', 'Bar', 'Bar']);
 
     // Flush the rest to make sure that the bailout didn't block this work.
-    expect(Scheduler).toFlushAndYield(['Middle']);
+    await waitForAll(['Middle']);
   });
 
-  xit('can resume work in a bailed subtree within one pass', () => {
+  xit('can resume work in a bailed subtree within one pass', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -440,37 +439,37 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo text="foo" />);
     ReactNoop.flushDeferredPri(52 + 5);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Tester', 'Bar']);
+    assertLog(['Foo', 'Bar', 'Tester', 'Bar']);
 
     // Make a quick update which will create a low pri tree on top of the
     // already low pri tree.
     ReactNoop.render(<Foo text="bar" />);
     ReactNoop.flushDeferredPri(15);
 
-    expect(Scheduler).toHaveYielded(['Foo']);
+    assertLog(['Foo']);
 
     // At this point, middle will bail out but it has not yet fully rendered.
     // Since that is the same priority as its parent tree. This should render
     // as a single batch. Therefore, it is correct that Middle should be in the
     // middle. If it occurs after the two "Bar" components then it was flushed
     // after them which is not correct.
-    expect(Scheduler).toFlushAndYield(['Bar', 'Middle', 'Bar']);
+    await waitForAll(['Bar', 'Middle', 'Bar']);
 
     // Let us try this again without fully finishing the first time. This will
     // create a hanging subtree that is reconciling at the normal priority.
     ReactNoop.render(<Foo text="foo" />);
     ReactNoop.flushDeferredPri(40);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
+    assertLog(['Foo', 'Bar']);
 
     // This update will create a tree that aborts that work and down-prioritizes
     // it. If the priority levels aren't down-prioritized correctly this may
     // abort rendering of the down-prioritized content.
     ReactNoop.render(<Foo text="bar" />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar']);
   });
 
-  xit('can resume mounting a class component', () => {
+  xit('can resume mounting a class component', async () => {
     let foo;
     class Parent extends React.Component {
       shouldComponentUpdate() {
@@ -501,14 +500,14 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Parent prop="foo" />);
     ReactNoop.flushDeferredPri(20);
-    expect(Scheduler).toHaveYielded(['Foo constructor: foo', 'Foo']);
+    assertLog(['Foo constructor: foo', 'Foo']);
 
     foo.setState({value: 'bar'});
 
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar']);
+    await waitForAll(['Foo', 'Bar']);
   });
 
-  xit('reuses the same instance when resuming a class instance', () => {
+  xit('reuses the same instance when resuming a class instance', async () => {
     let foo;
     class Parent extends React.Component {
       shouldComponentUpdate() {
@@ -560,7 +559,7 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Parent prop="foo" />);
     ReactNoop.flushDeferredPri(25);
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'constructor: foo',
       'componentWillMount: foo',
       'render: foo',
@@ -569,9 +568,9 @@ describe('ReactIncremental', () => {
 
     foo.setState({value: 'bar'});
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(constructorCount).toEqual(1);
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'componentWillMount: foo',
       'render: foo',
       'Foo did complete',
@@ -579,7 +578,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  xit('can reuse work done after being preempted', () => {
+  xit('can reuse work done after being preempted', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -622,42 +621,42 @@ describe('ReactIncremental', () => {
 
     // We only finish the higher priority work. So the low pri content
     // has not yet finished mounting.
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Middle', 'Bar']);
+    assertLog(['Foo', 'Bar', 'Middle', 'Bar']);
 
     // Interrupt the rendering with a quick update. This should not touch the
     // middle content.
     ReactNoop.render(<Foo text="foo" text2="bar" step={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // We've now rendered the entire tree but we didn't have to redo the work
     // done by the first Middle and Bar already.
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Middle']);
+    assertLog(['Foo', 'Bar', 'Middle']);
 
     // Make a quick update which will schedule low priority work to
     // update the middle content.
     ReactNoop.render(<Foo text="bar" text2="bar" step={1} />);
     ReactNoop.flushDeferredPri(30 + 25 + 5);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
+    assertLog(['Foo', 'Bar']);
 
     // The middle content is now pending rendering...
     ReactNoop.flushDeferredPri(30 + 5);
-    expect(Scheduler).toHaveYielded(['Middle', 'Bar']);
+    assertLog(['Middle', 'Bar']);
 
     // but we'll interrupt it to render some higher priority work.
     // The middle content will bailout so it remains untouched.
     ReactNoop.render(<Foo text="foo" text2="bar" step={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
+    assertLog(['Foo', 'Bar']);
 
     // Since we did nothing to the middle subtree during the interruption,
     // we should be able to reuse the reconciliation work that we already did
     // without restarting.
-    expect(Scheduler).toFlushAndYield(['Middle']);
+    await waitForAll(['Middle']);
   });
 
-  xit('can reuse work that began but did not complete, after being preempted', () => {
+  xit('can reuse work that began but did not complete, after being preempted', async () => {
     let child;
     let sibling;
 
@@ -705,13 +704,13 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Parent />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // Begin working on a low priority update to Child, but stop before
     // GreatGrandchild. Child and Grandchild begin but don't complete.
     child.setState({step: 1});
     ReactNoop.flushDeferredPri(30);
-    expect(Scheduler).toHaveYielded(['Child', 'Grandchild']);
+    assertLog(['Child', 'Grandchild']);
 
     // Interrupt the current low pri work with a high pri update elsewhere in
     // the tree.
@@ -719,19 +718,19 @@ describe('ReactIncremental', () => {
     ReactNoop.flushSync(() => {
       sibling.setState({});
     });
-    expect(Scheduler).toHaveYielded(['Sibling']);
+    assertLog(['Sibling']);
 
     // Continue the low pri work. The work on Child and GrandChild was memoized
     // so they should not be worked on again.
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // No Child
       // No Grandchild
       'GreatGrandchild',
     ]);
   });
 
-  xit('can reuse work if shouldComponentUpdate is false, after being preempted', () => {
+  xit('can reuse work if shouldComponentUpdate is false, after being preempted', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
@@ -777,40 +776,33 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" step={0} />);
-    expect(Scheduler).toFlushAndYield([
-      'Foo',
-      'Bar',
-      'Content',
-      'Middle',
-      'Bar',
-      'Middle',
-    ]);
+    await waitForAll(['Foo', 'Bar', 'Content', 'Middle', 'Bar', 'Middle']);
 
     // Make a quick update which will schedule low priority work to
     // update the middle content.
     ReactNoop.render(<Foo text="bar" step={1} />);
     ReactNoop.flushDeferredPri(30 + 5);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
+    assertLog(['Foo', 'Bar']);
 
     // The middle content is now pending rendering...
     ReactNoop.flushDeferredPri(30 + 25 + 5);
-    expect(Scheduler).toHaveYielded(['Content', 'Middle', 'Bar']); // One more Middle left.
+    assertLog(['Content', 'Middle', 'Bar']); // One more Middle left.
 
     // but we'll interrupt it to render some higher priority work.
     // The middle content will bailout so it remains untouched.
     ReactNoop.render(<Foo text="foo" step={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
+    assertLog(['Foo', 'Bar']);
 
     // Since we did nothing to the middle subtree during the interruption,
     // we should be able to reuse the reconciliation work that we already did
     // without restarting.
-    expect(Scheduler).toFlushAndYield(['Middle']);
+    await waitForAll(['Middle']);
   });
 
-  it('memoizes work even if shouldComponentUpdate returns false', () => {
+  it('memoizes work even if shouldComponentUpdate returns false', async () => {
     class Foo extends React.Component {
       shouldComponentUpdate(nextProps) {
         // this.props is the memoized props. So this should return true for
@@ -826,13 +818,13 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo step={1} />);
-    expect(Scheduler).toFlushAndYield(['render']);
+    await waitForAll(['render']);
 
     ReactNoop.render(<Foo step={2} />);
-    expect(Scheduler).toFlushAndYield(['shouldComponentUpdate: false']);
+    await waitForAll(['shouldComponentUpdate: false']);
 
     ReactNoop.render(<Foo step={3} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // If the memoized props were not updated during last bail out, sCU will
       // keep returning false.
       'shouldComponentUpdate: true',
@@ -840,7 +832,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('can update in the middle of a tree using setState', () => {
+  it('can update in the middle of a tree using setState', async () => {
     let instance;
     class Bar extends React.Component {
       constructor() {
@@ -862,14 +854,14 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state).toEqual({a: 'a'});
     instance.setState({b: 'b'});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state).toEqual({a: 'a', b: 'b'});
   });
 
-  it('can queue multiple state updates', () => {
+  it('can queue multiple state updates', async () => {
     let instance;
     class Bar extends React.Component {
       constructor() {
@@ -891,16 +883,16 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     // Call setState multiple times before flushing
     instance.setState({b: 'b'});
     instance.setState({c: 'c'});
     instance.setState({d: 'd'});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state).toEqual({a: 'a', b: 'b', c: 'c', d: 'd'});
   });
 
-  it('can use updater form of setState', () => {
+  it('can use updater form of setState', async () => {
     let instance;
     class Bar extends React.Component {
       constructor() {
@@ -926,19 +918,19 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo multiplier={2} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state.num).toEqual(1);
     instance.setState(updater);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state.num).toEqual(2);
 
     instance.setState(updater);
     ReactNoop.render(<Foo multiplier={3} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state.num).toEqual(6);
   });
 
-  it('can call setState inside update callback', () => {
+  it('can call setState inside update callback', async () => {
     let instance;
     class Bar extends React.Component {
       constructor() {
@@ -968,15 +960,15 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo multiplier={2} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     instance.setState(updater);
     instance.setState(updater, callback);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state.num).toEqual(4);
     expect(instance.state.called).toEqual(true);
   });
 
-  it('can replaceState', () => {
+  it('can replaceState', async () => {
     let instance;
     class Bar extends React.Component {
       state = {a: 'a'};
@@ -995,15 +987,15 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     instance.setState({b: 'b'});
     instance.setState({c: 'c'});
     instance.updater.enqueueReplaceState(instance, {d: 'd'});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state).toEqual({d: 'd'});
   });
 
-  it('can forceUpdate', () => {
+  it('can forceUpdate', async () => {
     function Baz() {
       Scheduler.unstable_yieldValue('Baz');
       return <div />;
@@ -1034,12 +1026,12 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Baz']);
+    await waitForAll(['Foo', 'Bar', 'Baz']);
     instance.forceUpdate();
-    expect(Scheduler).toFlushAndYield(['Bar', 'Baz']);
+    await waitForAll(['Bar', 'Baz']);
   });
 
-  it('should clear forceUpdate after update is flushed', () => {
+  it('should clear forceUpdate after update is flushed', async () => {
     let a = 0;
 
     class Foo extends React.PureComponent {
@@ -1052,14 +1044,14 @@ describe('ReactIncremental', () => {
 
     const foo = React.createRef(null);
     ReactNoop.render(<Foo ref={foo} b={0} />);
-    expect(Scheduler).toFlushAndYield(['A: 0, B: 0']);
+    await waitForAll(['A: 0, B: 0']);
 
     a = 1;
     foo.current.forceUpdate();
-    expect(Scheduler).toFlushAndYield(['A: 1, B: 0']);
+    await waitForAll(['A: 1, B: 0']);
 
     ReactNoop.render(<Foo ref={foo} b={0} />);
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
   });
 
   xit('can call sCU while resuming a partly mounted component', () => {
@@ -1092,7 +1084,7 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Foo step={0} />);
     ReactNoop.flushDeferredPri(40);
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar:A', 'Bar:B', 'Bar:C']);
+    assertLog(['Foo', 'Bar:A', 'Bar:B', 'Bar:C']);
 
     expect(instances.size).toBe(3);
 
@@ -1101,13 +1093,13 @@ describe('ReactIncremental', () => {
     // A was memoized and reused. B was memoized but couldn't be reused because
     // props differences. C was memoized and reused. D never even started so it
     // needed a new instance.
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar:B2', 'Bar:D']);
+    assertLog(['Foo', 'Bar:B2', 'Bar:D']);
 
     // We expect each rerender to correspond to a new instance.
     expect(instances.size).toBe(4);
   });
 
-  xit('gets new props when setting state on a partly updated component', () => {
+  xit('gets new props when setting state on a partly updated component', async () => {
     const instances = [];
 
     class Bar extends React.Component {
@@ -1151,7 +1143,7 @@ describe('ReactIncremental', () => {
         <Baz />
       </div>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // Flush part way through with new props, fully completing the first Bar.
     // However, it doesn't commit yet.
@@ -1163,15 +1155,15 @@ describe('ReactIncremental', () => {
       </div>,
     );
     ReactNoop.flushDeferredPri(45);
-    expect(Scheduler).toHaveYielded(['Foo', 'Bar:A-1', 'Bar:B-1', 'Baz']);
+    assertLog(['Foo', 'Bar:A-1', 'Bar:B-1', 'Baz']);
 
     // Make an update to the same Bar.
     instances[0].performAction();
 
-    expect(Scheduler).toFlushAndYield(['Bar:A-1', 'Baz']);
+    await waitForAll(['Bar:A-1', 'Baz']);
   });
 
-  xit('calls componentWillMount twice if the initial render is aborted', () => {
+  xit('calls componentWillMount twice if the initial render is aborted', async () => {
     class LifeCycle extends React.Component {
       state = {x: this.props.x};
       UNSAFE_componentWillReceiveProps(nextProps) {
@@ -1213,10 +1205,10 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<App x={0} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded(['App', 'componentWillMount:0-0']);
+    assertLog(['App', 'componentWillMount:0-0']);
 
     ReactNoop.render(<App x={1} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'App',
       'componentWillReceiveProps:0-1',
       'componentWillMount:1-1',
@@ -1225,7 +1217,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  xit('uses state set in componentWillMount even if initial render was aborted', () => {
+  xit('uses state set in componentWillMount even if initial render was aborted', async () => {
     class LifeCycle extends React.Component {
       constructor(props) {
         super(props);
@@ -1252,14 +1244,10 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<App x={0} />);
     ReactNoop.flushDeferredPri(20);
 
-    expect(Scheduler).toHaveYielded([
-      'App',
-      'componentWillMount:0(ctor)',
-      'render:0(willMount)',
-    ]);
+    assertLog(['App', 'componentWillMount:0(ctor)', 'render:0(willMount)']);
 
     ReactNoop.render(<App x={1} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'App',
       'componentWillMount:0(willMount)',
       'render:1(willMount)',
@@ -1267,7 +1255,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  xit('calls componentWill* twice if an update render is aborted', () => {
+  xit('calls componentWill* twice if an update render is aborted', async () => {
     class LifeCycle extends React.Component {
       UNSAFE_componentWillMount() {
         Scheduler.unstable_yieldValue('componentWillMount:' + this.props.x);
@@ -1316,7 +1304,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'App',
       'componentWillMount:0',
       'render:0',
@@ -1327,7 +1315,7 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<App x={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'App',
       'componentWillReceiveProps:0-1',
       'shouldComponentUpdate:0-1',
@@ -1338,7 +1326,7 @@ describe('ReactIncremental', () => {
     ]);
 
     ReactNoop.render(<App x={2} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'App',
       'componentWillReceiveProps:1-2',
       'shouldComponentUpdate:1-2',
@@ -1350,7 +1338,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('calls getDerivedStateFromProps even for state-only updates', () => {
+  it('calls getDerivedStateFromProps even for state-only updates', async () => {
     let instance;
 
     class LifeCycle extends React.Component {
@@ -1373,11 +1361,11 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<LifeCycle />);
-    expect(Scheduler).toFlushAndYield(['getDerivedStateFromProps', 'render']);
+    await waitForAll(['getDerivedStateFromProps', 'render']);
     expect(instance.state).toEqual({foo: 'foo'});
 
     instance.changeState();
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'getDerivedStateFromProps',
       'render',
       'componentDidUpdate',
@@ -1385,7 +1373,7 @@ describe('ReactIncremental', () => {
     expect(instance.state).toEqual({foo: 'foo'});
   });
 
-  it('does not call getDerivedStateFromProps if neither state nor props have changed', () => {
+  it('does not call getDerivedStateFromProps if neither state nor props have changed', async () => {
     class Parent extends React.Component {
       state = {parentRenders: 0};
       static getDerivedStateFromProps(props, prevState) {
@@ -1407,18 +1395,14 @@ describe('ReactIncremental', () => {
 
     const child = React.createRef(null);
     ReactNoop.render(<Parent />);
-    expect(Scheduler).toFlushAndYield([
-      'getDerivedStateFromProps',
-      'Parent',
-      'Child',
-    ]);
+    await waitForAll(['getDerivedStateFromProps', 'Parent', 'Child']);
 
     // Schedule an update on the child. The parent should not re-render.
     child.current.setState({});
-    expect(Scheduler).toFlushAndYield(['Child']);
+    await waitForAll(['Child']);
   });
 
-  xit('does not call componentWillReceiveProps for state-only updates', () => {
+  xit('does not call componentWillReceiveProps for state-only updates', async () => {
     const instances = [];
 
     class LifeCycle extends React.Component {
@@ -1492,7 +1476,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<App y={0} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'App',
       'Wrap',
       'componentWillMount:0',
@@ -1506,7 +1490,7 @@ describe('ReactIncremental', () => {
 
     ReactNoop.flushDeferredPri(25);
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       // no componentWillReceiveProps
       'shouldComponentUpdate:0-1',
       'componentWillUpdate:0-1',
@@ -1517,7 +1501,7 @@ describe('ReactIncremental', () => {
     // LifeCycle
     instances[1].tick();
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // no componentWillReceiveProps
       'shouldComponentUpdate:1-2',
       'componentWillUpdate:1-2',
@@ -1532,7 +1516,7 @@ describe('ReactIncremental', () => {
 
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'Wrap',
       'componentWillReceiveProps',
       'shouldComponentUpdate:2-2',
@@ -1544,7 +1528,7 @@ describe('ReactIncremental', () => {
     // Next we will update LifeCycle directly but not with new props.
     instances[1].tick();
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // This should not trigger another componentWillReceiveProps because
       // we never got new props.
       'shouldComponentUpdate:2-3',
@@ -1557,7 +1541,7 @@ describe('ReactIncremental', () => {
     // incomplete parents.
   });
 
-  xit('skips will/DidUpdate when bailing unless an update was already in progress', () => {
+  xit('skips will/DidUpdate when bailing unless an update was already in progress', async () => {
     class LifeCycle extends React.Component {
       UNSAFE_componentWillMount() {
         Scheduler.unstable_yieldValue('componentWillMount');
@@ -1595,7 +1579,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'componentWillMount',
       'render',
       'render sibling',
@@ -1604,7 +1588,7 @@ describe('ReactIncremental', () => {
 
     // Update to same props
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       // no componentWillUpdate
@@ -1617,7 +1601,7 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<App x={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       'componentWillUpdate',
@@ -1628,10 +1612,10 @@ describe('ReactIncremental', () => {
 
     // ...but we'll interrupt it to rerender the same props.
     ReactNoop.render(<App x={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // We can bail out this time, but we must call componentDidUpdate.
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       // no componentWillUpdate
@@ -1641,7 +1625,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('can nest batchedUpdates', () => {
+  it('can nest batchedUpdates', async () => {
     let instance;
 
     class Foo extends React.Component {
@@ -1653,7 +1637,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     ReactNoop.flushSync(() => {
       ReactNoop.batchedUpdates(() => {
@@ -1678,7 +1662,7 @@ describe('ReactIncremental', () => {
 
     // ReactNoop.flush() not needed because updates are synchronous
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'end inner batchedUpdates',
       'end outer batchedUpdates',
       'setState 1',
@@ -1689,7 +1673,7 @@ describe('ReactIncremental', () => {
     expect(instance.state.n).toEqual(4);
   });
 
-  it('can handle if setState callback throws', () => {
+  it('can handle if setState callback throws', async () => {
     let instance;
 
     class Foo extends React.Component {
@@ -1701,7 +1685,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     function updater({n}) {
       return {n: n + 1};
@@ -1718,16 +1702,14 @@ describe('ReactIncremental', () => {
       Scheduler.unstable_yieldValue('third callback'),
     );
 
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('callback error');
+    await waitForThrow('callback error');
 
     // The third callback isn't called because the second one throws
-    expect(Scheduler).toHaveYielded(['first callback', 'second callback']);
+    assertLog(['first callback', 'second callback']);
     expect(instance.state.n).toEqual(3);
   });
 
-  it('merges and masks context', () => {
+  it('merges and masks context', async () => {
     class Intl extends React.Component {
       static childContextTypes = {
         locale: PropTypes.string,
@@ -1825,7 +1807,7 @@ describe('ReactIncremental', () => {
         </div>
       </Intl>,
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Intl {}',
       'ShowLocale {"locale":"fr"}',
       'ShowBoth {"locale":"fr"}',
@@ -1839,7 +1821,7 @@ describe('ReactIncremental', () => {
         </div>
       </Intl>,
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Intl {}',
       'ShowLocale {"locale":"de"}',
       'ShowBoth {"locale":"de"}',
@@ -1854,7 +1836,7 @@ describe('ReactIncremental', () => {
         </Intl>,
       );
     });
-    expect(Scheduler).toFlushAndYieldThrough(['Intl {}']);
+    await waitFor(['Intl {}']);
 
     ReactNoop.render(
       <Intl locale="en">
@@ -1865,7 +1847,7 @@ describe('ReactIncremental', () => {
         <ShowBoth />
       </Intl>,
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'ShowLocale {"locale":"sv"}',
       'ShowBoth {"locale":"sv"}',
       'Intl {}',
@@ -1882,7 +1864,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('does not leak own context into context provider', () => {
+  it('does not leak own context into context provider', async () => {
     class Recurse extends React.Component {
       static contextTypes = {
         n: PropTypes.number,
@@ -1905,7 +1887,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Recurse />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Recurse {}',
       'Recurse {"n":2}',
       'Recurse {"n":1}',
@@ -1955,7 +1937,7 @@ describe('ReactIncremental', () => {
   }
 
   // @gate www
-  it('provides context when reusing work', () => {
+  it('provides context when reusing work', async () => {
     class Intl extends React.Component {
       static childContextTypes = {
         locale: PropTypes.string,
@@ -1997,20 +1979,20 @@ describe('ReactIncremental', () => {
         </Intl>,
       );
     });
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'Intl {}',
       'ShowLocale {"locale":"fr"}',
       'ShowLocale {"locale":"fr"}',
     ]);
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'ShowLocale {"locale":"fr"}',
       'Intl {}',
       'ShowLocale {"locale":"ru"}',
     ]);
   });
 
-  it('reads context when setState is below the provider', () => {
+  it('reads context when setState is below the provider', async () => {
     let statefulInst;
 
     class Intl extends React.Component {
@@ -2090,7 +2072,7 @@ describe('ReactIncremental', () => {
         </IndirectionFn>
       </Intl>,
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Intl:read {}',
       'Intl:provide {"locale":"fr"}',
       'IndirectionFn {}',
@@ -2100,13 +2082,13 @@ describe('ReactIncremental', () => {
     ]);
 
     statefulInst.setState({x: 1});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     // All work has been memoized because setState()
     // happened below the context and could not have affected it.
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
   });
 
-  it('reads context when setState is above the provider', () => {
+  it('reads context when setState is above the provider', async () => {
     let statefulInst;
 
     class Intl extends React.Component {
@@ -2184,7 +2166,7 @@ describe('ReactIncremental', () => {
         </IndirectionFn>
       </Stateful>,
     );
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'Intl:read {}',
       'Intl:provide {"locale":"fr"}',
       'IndirectionFn {}',
@@ -2194,7 +2176,7 @@ describe('ReactIncremental', () => {
     ]);
 
     statefulInst.setState({locale: 'gr'});
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // Intl is below setState() so it might have been
       // affected by it. Therefore we re-render and recompute
       // its child context.
@@ -2210,7 +2192,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  it('maintains the correct context when providers bail out due to low priority', () => {
+  it('maintains the correct context when providers bail out due to low priority', async () => {
     class Root extends React.Component {
       render() {
         return <Middle {...this.props} />;
@@ -2246,14 +2228,14 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Root />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // Trigger an update in the middle of the tree
     instance.setState({});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
   });
 
-  it('maintains the correct context when unwinding due to an error in render', () => {
+  it('maintains the correct context when unwinding due to an error in render', async () => {
     class Root extends React.Component {
       componentDidCatch(error) {
         // If context is pushed/popped correctly,
@@ -2292,7 +2274,7 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Root />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // Trigger an update in the middle of the tree
     // This is necessary to reproduce the error as it currently exists.
@@ -2304,7 +2286,7 @@ describe('ReactIncremental', () => {
     );
   });
 
-  it('should not recreate masked context unless inputs have changed', () => {
+  it('should not recreate masked context unless inputs have changed', async () => {
     let scuCounter = 0;
 
     class MyComponent extends React.Component {
@@ -2334,7 +2316,7 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<MyComponent />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'render',
       'componentDidMount',
       'shouldComponentUpdate',
@@ -2346,7 +2328,7 @@ describe('ReactIncremental', () => {
     ]);
   });
 
-  xit('should reuse memoized work if pointers are updated before calling lifecycles', () => {
+  xit('should reuse memoized work if pointers are updated before calling lifecycles', async () => {
     const cduNextProps = [];
     const cduPrevProps = [];
     const scuNextProps = [];
@@ -2395,7 +2377,7 @@ describe('ReactIncremental', () => {
     // Initial render of the entire tree.
     // Renders: Root, Middle, FirstChild, SecondChild
     ReactNoop.render(<Root>A</Root>);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     expect(renderCounter).toBe(1);
 
@@ -2417,7 +2399,7 @@ describe('ReactIncremental', () => {
     // The in-progress child content will bailout.
     // Renders: Root, Middle, FirstChild, SecondChild
     ReactNoop.render(<Root>B</Root>);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // At this point the higher priority render has completed.
     // Since FirstChild props didn't change, sCU returned false.
@@ -2429,7 +2411,7 @@ describe('ReactIncremental', () => {
     expect(cduNextProps).toEqual([{children: 'B'}]);
   });
 
-  it('updates descendants with new context values', () => {
+  it('updates descendants with new context values', async () => {
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2473,12 +2455,12 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(Scheduler).toFlushAndYield(['count:0']);
+    await waitForAll(['count:0']);
     instance.updateCount();
-    expect(Scheduler).toFlushAndYield(['count:1']);
+    await waitForAll(['count:1']);
   });
 
-  it('updates descendants with multiple context-providing ancestors with new context values', () => {
+  it('updates descendants with multiple context-providing ancestors with new context values', async () => {
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2528,12 +2510,12 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(Scheduler).toFlushAndYield(['count:0']);
+    await waitForAll(['count:0']);
     instance.updateCount();
-    expect(Scheduler).toFlushAndYield(['count:1']);
+    await waitForAll(['count:1']);
   });
 
-  it('should not update descendants with new context values if shouldComponentUpdate returns false', () => {
+  it('should not update descendants with new context values if shouldComponentUpdate returns false', async () => {
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2592,12 +2574,12 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(Scheduler).toFlushAndYield(['count:0']);
+    await waitForAll(['count:0']);
     instance.updateCount();
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
   });
 
-  it('should update descendants with new context values if setState() is called in the middle of the tree', () => {
+  it('should update descendants with new context values if setState() is called in the middle of the tree', async () => {
     let middleInstance;
     let topInstance;
 
@@ -2668,14 +2650,14 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(Scheduler).toFlushAndYield(['count:0, name:brian']);
+    await waitForAll(['count:0, name:brian']);
     topInstance.updateCount();
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     middleInstance.updateName('not brian');
-    expect(Scheduler).toFlushAndYield(['count:1, name:not brian']);
+    await waitForAll(['count:1, name:not brian']);
   });
 
-  it('does not interrupt for update at same priority', () => {
+  it('does not interrupt for update at same priority', async () => {
     function Parent(props) {
       Scheduler.unstable_yieldValue('Parent: ' + props.step);
       return <Child step={props.step} />;
@@ -2689,15 +2671,15 @@ describe('ReactIncremental', () => {
     React.startTransition(() => {
       ReactNoop.render(<Parent step={1} />);
     });
-    expect(Scheduler).toFlushAndYieldThrough(['Parent: 1']);
+    await waitFor(['Parent: 1']);
 
     // Interrupt at same priority
     ReactNoop.render(<Parent step={2} />);
 
-    expect(Scheduler).toFlushAndYield(['Child: 1', 'Parent: 2', 'Child: 2']);
+    await waitForAll(['Child: 1', 'Parent: 2', 'Child: 2']);
   });
 
-  it('does not interrupt for update at lower priority', () => {
+  it('does not interrupt for update at lower priority', async () => {
     function Parent(props) {
       Scheduler.unstable_yieldValue('Parent: ' + props.step);
       return <Child step={props.step} />;
@@ -2711,16 +2693,16 @@ describe('ReactIncremental', () => {
     React.startTransition(() => {
       ReactNoop.render(<Parent step={1} />);
     });
-    expect(Scheduler).toFlushAndYieldThrough(['Parent: 1']);
+    await waitFor(['Parent: 1']);
 
     // Interrupt at lower priority
     ReactNoop.expire(2000);
     ReactNoop.render(<Parent step={2} />);
 
-    expect(Scheduler).toFlushAndYield(['Child: 1', 'Parent: 2', 'Child: 2']);
+    await waitForAll(['Child: 1', 'Parent: 2', 'Child: 2']);
   });
 
-  it('does interrupt for update at higher priority', () => {
+  it('does interrupt for update at higher priority', async () => {
     function Parent(props) {
       Scheduler.unstable_yieldValue('Parent: ' + props.step);
       return <Child step={props.step} />;
@@ -2734,20 +2716,20 @@ describe('ReactIncremental', () => {
     React.startTransition(() => {
       ReactNoop.render(<Parent step={1} />);
     });
-    expect(Scheduler).toFlushAndYieldThrough(['Parent: 1']);
+    await waitFor(['Parent: 1']);
 
     // Interrupt at higher priority
     ReactNoop.flushSync(() => ReactNoop.render(<Parent step={2} />));
-    expect(Scheduler).toHaveYielded(['Parent: 2', 'Child: 2']);
+    assertLog(['Parent: 2', 'Child: 2']);
 
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
   });
 
   // We sometimes use Maps with Fibers as keys.
-  it('does not break with a bad Map polyfill', () => {
+  it('does not break with a bad Map polyfill', async () => {
     const realMapSet = Map.prototype.set;
 
-    function triggerCodePathThatUsesFibersAsMapKeys() {
+    async function triggerCodePathThatUsesFibersAsMapKeys() {
       function Thing() {
         throw new Error('No.');
       }
@@ -2770,8 +2752,8 @@ describe('ReactIncremental', () => {
           <Boundary />
         </React.StrictMode>,
       );
-      expect(() => {
-        expect(Scheduler).toFlushWithoutYielding();
+      await expect(async () => {
+        await waitForAll([]);
       }).toErrorDev([
         'Legacy context API has been detected within a strict-mode tree',
       ]);
@@ -2793,9 +2775,15 @@ describe('ReactIncremental', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+    let InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    waitForThrow = InternalTestUtils.waitForThrow;
+    assertLog = InternalTestUtils.assertLog;
+
     try {
       receivedNonExtensibleObjects = false;
-      triggerCodePathThatUsesFibersAsMapKeys();
+      await triggerCodePathThatUsesFibersAsMapKeys();
     } finally {
       // eslint-disable-next-line no-extend-native
       Map.prototype.set = realMapSet;
@@ -2821,8 +2809,14 @@ describe('ReactIncremental', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+    InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    waitForThrow = InternalTestUtils.waitForThrow;
+    assertLog = InternalTestUtils.assertLog;
+
     try {
-      triggerCodePathThatUsesFibersAsMapKeys();
+      await triggerCodePathThatUsesFibersAsMapKeys();
     } finally {
       // eslint-disable-next-line no-extend-native
       Map.prototype.set = realMapSet;
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
index 547efa26faf84..5e72bfe95d011 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
@@ -16,6 +16,10 @@ let React;
 let ReactNoop;
 let Scheduler;
 let act;
+let assertLog;
+let waitForAll;
+let waitFor;
+let waitForThrow;
 
 describe('ReactIncrementalErrorHandling', () => {
   beforeEach(() => {
@@ -27,6 +31,12 @@ describe('ReactIncrementalErrorHandling', () => {
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
     act = require('jest-react').act;
+
+    const InternalTestUtils = require('internal-test-utils');
+    assertLog = InternalTestUtils.assertLog;
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    waitForThrow = InternalTestUtils.waitForThrow;
   });
 
   afterEach(() => {
@@ -55,7 +65,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   }
 
-  it('recovers from errors asynchronously', () => {
+  it('recovers from errors asynchronously', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       static getDerivedStateFromError(error) {
@@ -104,7 +114,7 @@ describe('ReactIncrementalErrorHandling', () => {
     });
 
     // Start rendering asynchronously
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'ErrorBoundary (try)',
       'Indirection',
       'Indirection',
@@ -114,9 +124,9 @@ describe('ReactIncrementalErrorHandling', () => {
     ]);
 
     // Still rendering async...
-    expect(Scheduler).toFlushAndYieldThrough(['Indirection']);
+    await waitFor(['Indirection']);
 
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'Indirection',
 
       // Call getDerivedStateFromError and re-render the error boundary, this
@@ -153,7 +163,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('recovers from errors asynchronously (legacy, no getDerivedStateFromError)', () => {
+  it('recovers from errors asynchronously (legacy, no getDerivedStateFromError)', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -202,7 +212,7 @@ describe('ReactIncrementalErrorHandling', () => {
     });
 
     // Start rendering asynchronously
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'ErrorBoundary (try)',
       'Indirection',
       'Indirection',
@@ -212,9 +222,9 @@ describe('ReactIncrementalErrorHandling', () => {
     ]);
 
     // Still rendering async...
-    expect(Scheduler).toFlushAndYieldThrough(['Indirection']);
+    await waitFor(['Indirection']);
 
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'Indirection',
       // Now that the tree is complete, and there's no remaining work, React
       // reverts to legacy mode to retry one more time before handling the error.
@@ -254,7 +264,7 @@ describe('ReactIncrementalErrorHandling', () => {
     React.startTransition(() => {
       ReactNoop.render(<App isBroken={true} />, onCommit);
     });
-    expect(Scheduler).toFlushAndYieldThrough(['error']);
+    await waitFor(['error']);
 
     React.startTransition(() => {
       // This update is in a separate batch
@@ -268,7 +278,7 @@ describe('ReactIncrementalErrorHandling', () => {
     // to recover from the error is synchronous, this should be enough to
     // finish the rest of the work.
     Scheduler.unstable_flushNumberOfYields(1);
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'success',
       // Nothing commits until the second update completes.
       'commit',
@@ -280,7 +290,7 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   // @gate www
-  it('does not include offscreen work when retrying after an error', () => {
+  it('does not include offscreen work when retrying after an error', async () => {
     function App(props) {
       if (props.isBroken) {
         Scheduler.unstable_yieldValue('error');
@@ -304,7 +314,7 @@ describe('ReactIncrementalErrorHandling', () => {
     React.startTransition(() => {
       ReactNoop.render(<App isBroken={true} />, onCommit);
     });
-    expect(Scheduler).toFlushAndYieldThrough(['error']);
+    await waitFor(['error']);
 
     expect(ReactNoop).toMatchRenderedOutput(null);
 
@@ -320,7 +330,7 @@ describe('ReactIncrementalErrorHandling', () => {
     // to recover from the error is synchronous, this should be enough to
     // finish the rest of the work.
     Scheduler.unstable_flushNumberOfYields(1);
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'success',
       // Nothing commits until the second update completes.
       'commit',
@@ -335,7 +345,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
 
     // The offscreen content finishes in a subsequent render
-    expect(Scheduler).toFlushAndYield([]);
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <>
         Everything is fine
@@ -346,7 +356,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('retries one more time before handling error', () => {
+  it('retries one more time before handling error', async () => {
     function BadRender({unused}) {
       Scheduler.unstable_yieldValue('BadRender');
       throw new Error('oops');
@@ -374,19 +384,14 @@ describe('ReactIncrementalErrorHandling', () => {
     });
 
     // Render the bad component asynchronously
-    expect(Scheduler).toFlushAndYieldThrough(['Parent', 'BadRender']);
+    await waitFor(['Parent', 'BadRender']);
 
     // Finish the rest of the async work
-    expect(Scheduler).toFlushAndYieldThrough(['Sibling']);
+    await waitFor(['Sibling']);
 
     // Old scheduler renders, commits, and throws synchronously
     expect(() => Scheduler.unstable_flushNumberOfYields(1)).toThrow('oops');
-    expect(Scheduler).toHaveYielded([
-      'Parent',
-      'BadRender',
-      'Sibling',
-      'commit',
-    ]);
+    assertLog(['Parent', 'BadRender', 'Sibling', 'commit']);
     expect(ReactNoop).toMatchRenderedOutput(null);
   });
 
@@ -418,7 +423,7 @@ describe('ReactIncrementalErrorHandling', () => {
     });
 
     // Render part of the tree
-    expect(Scheduler).toFlushAndYieldThrough(['A', 'B']);
+    await waitFor(['A', 'B']);
 
     // Expire the render midway through
     Scheduler.unstable_advanceTime(10000);
@@ -428,7 +433,7 @@ describe('ReactIncrementalErrorHandling', () => {
       ReactNoop.flushSync();
     }).toThrow('Oops');
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       // The render expired, but we shouldn't throw out the partial work.
       // Finish the current level.
       'Oops',
@@ -446,7 +451,7 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(ReactNoop).toMatchRenderedOutput(null);
   });
 
-  it('calls componentDidCatch multiple times for multiple errors', () => {
+  it('calls componentDidCatch multiple times for multiple errors', async () => {
     let id = 0;
     class BadMount extends React.Component {
       componentDidMount() {
@@ -481,7 +486,7 @@ describe('ReactIncrementalErrorHandling', () => {
       </ErrorBoundary>,
     );
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'ErrorBoundary',
       'BadMount',
       'BadMount',
@@ -495,7 +500,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('catches render error in a boundary during full deferred mounting', () => {
+  it('catches render error in a boundary during full deferred mounting', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -520,13 +525,13 @@ describe('ReactIncrementalErrorHandling', () => {
         <BrokenRender />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <span prop="Caught an error: Hello." />,
     );
   });
 
-  it('catches render error in a boundary during partial deferred mounting', () => {
+  it('catches render error in a boundary during partial deferred mounting', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -558,10 +563,10 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(Scheduler).toFlushAndYieldThrough(['ErrorBoundary render success']);
+    await waitFor(['ErrorBoundary render success']);
     expect(ReactNoop).toMatchRenderedOutput(null);
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'BrokenRender',
       // React retries one more time
       'ErrorBoundary render success',
@@ -608,7 +613,7 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'ErrorBoundary render success',
       'BrokenRender',
 
@@ -658,7 +663,7 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'ErrorBoundary render success',
       'BrokenRender',
 
@@ -675,7 +680,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('propagates an error from a noop error boundary during full deferred mounting', () => {
+  it('propagates an error from a noop error boundary during full deferred mounting', async () => {
     class RethrowErrorBoundary extends React.Component {
       componentDidCatch(error) {
         Scheduler.unstable_yieldValue('RethrowErrorBoundary componentDidCatch');
@@ -698,23 +703,22 @@ describe('ReactIncrementalErrorHandling', () => {
       </RethrowErrorBoundary>,
     );
 
-    expect(() => {
-      expect(Scheduler).toFlushAndYield([
-        'RethrowErrorBoundary render',
-        'BrokenRender',
+    await waitForThrow('Hello');
+    assertLog([
+      'RethrowErrorBoundary render',
+      'BrokenRender',
 
-        // React retries one more time
-        'RethrowErrorBoundary render',
-        'BrokenRender',
+      // React retries one more time
+      'RethrowErrorBoundary render',
+      'BrokenRender',
 
-        // Errored again on retry. Now handle it.
-        'RethrowErrorBoundary componentDidCatch',
-      ]);
-    }).toThrow('Hello');
+      // Errored again on retry. Now handle it.
+      'RethrowErrorBoundary componentDidCatch',
+    ]);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(null);
   });
 
-  it('propagates an error from a noop error boundary during partial deferred mounting', () => {
+  it('propagates an error from a noop error boundary during partial deferred mounting', async () => {
     class RethrowErrorBoundary extends React.Component {
       componentDidCatch(error) {
         Scheduler.unstable_yieldValue('RethrowErrorBoundary componentDidCatch');
@@ -739,12 +743,10 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(Scheduler).toFlushAndYieldThrough(['RethrowErrorBoundary render']);
+    await waitFor(['RethrowErrorBoundary render']);
 
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('Hello');
-    expect(Scheduler).toHaveYielded([
+    await waitForThrow('Hello');
+    assertLog([
       'BrokenRender',
 
       // React retries one more time
@@ -783,7 +785,7 @@ describe('ReactIncrementalErrorHandling', () => {
         );
       });
     }).toThrow('Hello');
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'RethrowErrorBoundary render',
       'BrokenRender',
 
@@ -826,7 +828,7 @@ describe('ReactIncrementalErrorHandling', () => {
         );
       });
     }).toThrow('Hello');
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'RethrowErrorBoundary render',
       'BrokenRender',
 
@@ -840,7 +842,7 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(ReactNoop).toMatchRenderedOutput(null);
   });
 
-  it('applies batched updates regardless despite errors in scheduling', () => {
+  it('applies batched updates regardless despite errors in scheduling', async () => {
     ReactNoop.render(<span prop="a:1" />);
     expect(() => {
       ReactNoop.batchedUpdates(() => {
@@ -849,11 +851,11 @@ describe('ReactIncrementalErrorHandling', () => {
         throw new Error('Hello');
       });
     }).toThrow('Hello');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="a:3" />);
   });
 
-  it('applies nested batched updates despite errors in scheduling', () => {
+  it('applies nested batched updates despite errors in scheduling', async () => {
     ReactNoop.render(<span prop="a:1" />);
     expect(() => {
       ReactNoop.batchedUpdates(() => {
@@ -866,12 +868,12 @@ describe('ReactIncrementalErrorHandling', () => {
         });
       });
     }).toThrow('Hello');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="a:5" />);
   });
 
   // TODO: Is this a breaking change?
-  it('defers additional sync work to a separate event after an error', () => {
+  it('defers additional sync work to a separate event after an error', async () => {
     ReactNoop.render(<span prop="a:1" />);
     expect(() => {
       ReactNoop.flushSync(() => {
@@ -882,11 +884,11 @@ describe('ReactIncrementalErrorHandling', () => {
         });
       });
     }).toThrow('Hello');
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="a:3" />);
   });
 
-  it('can schedule updates after uncaught error in render on mount', () => {
+  it('can schedule updates after uncaught error in render on mount', async () => {
     function BrokenRender({unused}) {
       Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
@@ -898,20 +900,18 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<BrokenRender />);
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('Hello');
+    await waitForThrow('Hello');
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'BrokenRender',
       // React retries one more time
       'BrokenRender',
       // Errored again on retry
     ]);
-    expect(Scheduler).toFlushAndYield(['Foo']);
+    await waitForAll(['Foo']);
   });
 
-  it('can schedule updates after uncaught error in render on update', () => {
+  it('can schedule updates after uncaught error in render on update', async () => {
     function BrokenRender({shouldThrow}) {
       Scheduler.unstable_yieldValue('BrokenRender');
       if (shouldThrow) {
@@ -926,13 +926,11 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<BrokenRender shouldThrow={false} />);
-    expect(Scheduler).toFlushAndYield(['BrokenRender']);
+    await waitForAll(['BrokenRender']);
 
-    expect(() => {
-      ReactNoop.render(<BrokenRender shouldThrow={true} />);
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('Hello');
-    expect(Scheduler).toHaveYielded([
+    ReactNoop.render(<BrokenRender shouldThrow={true} />);
+    await waitForThrow('Hello');
+    assertLog([
       'BrokenRender',
       // React retries one more time
       'BrokenRender',
@@ -940,10 +938,10 @@ describe('ReactIncrementalErrorHandling', () => {
     ]);
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['Foo']);
+    await waitForAll(['Foo']);
   });
 
-  it('can schedule updates after uncaught error during unmounting', () => {
+  it('can schedule updates after uncaught error during unmounting', async () => {
     class BrokenComponentWillUnmount extends React.Component {
       render() {
         return <div />;
@@ -959,19 +957,17 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<BrokenComponentWillUnmount />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
-    expect(() => {
-      ReactNoop.render(<div />);
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('Hello');
+    ReactNoop.render(<div />);
+    await waitForThrow('Hello');
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['Foo']);
+    await waitForAll(['Foo']);
   });
 
   // @gate skipUnmountedBoundaries
-  it('should not attempt to recover an unmounting error boundary', () => {
+  it('should not attempt to recover an unmounting error boundary', async () => {
     class Parent extends React.Component {
       componentWillUnmount() {
         Scheduler.unstable_yieldValue('Parent componentWillUnmount');
@@ -1001,22 +997,21 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<Parent />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // Because the error boundary is also unmounting,
     // an error in ThrowsOnUnmount should be rethrown.
-    expect(() => {
-      ReactNoop.render(null);
-      expect(Scheduler).toFlushAndYield([
-        'Parent componentWillUnmount',
-        'ThrowsOnUnmount componentWillUnmount',
-      ]);
-    }).toThrow('unmount error');
+    ReactNoop.render(null);
+    await waitForThrow('unmount error');
+    await assertLog([
+      'Parent componentWillUnmount',
+      'ThrowsOnUnmount componentWillUnmount',
+    ]);
 
     ReactNoop.render(<Parent />);
   });
 
-  it('can unmount an error boundary before it is handled', () => {
+  it('can unmount an error boundary before it is handled', async () => {
     let parent;
 
     class Parent extends React.Component {
@@ -1045,14 +1040,14 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<Parent />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Parent />);
     });
   });
 
-  it('continues work on other roots despite caught errors', () => {
+  it('continues work on other roots despite caught errors', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -1079,50 +1074,42 @@ describe('ReactIncrementalErrorHandling', () => {
       'a',
     );
     ReactNoop.renderToRootWithID(<span prop="b:1" />, 'b');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(
       <span prop="Caught an error: Hello." />,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(<span prop="b:1" />);
   });
 
-  it('continues work on other roots despite uncaught errors', () => {
+  it('continues work on other roots despite uncaught errors', async () => {
     function BrokenRender(props) {
       throw new Error(props.label);
     }
 
     ReactNoop.renderToRootWithID(<BrokenRender label="a" />, 'a');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('a');
+    await waitForThrow('a');
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(null);
 
     ReactNoop.renderToRootWithID(<BrokenRender label="a" />, 'a');
     ReactNoop.renderToRootWithID(<span prop="b:2" />, 'b');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('a');
+    await waitForThrow('a');
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(null);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(<span prop="b:2" />);
 
     ReactNoop.renderToRootWithID(<span prop="a:3" />, 'a');
     ReactNoop.renderToRootWithID(<BrokenRender label="b" />, 'b');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('b');
+    await waitForThrow('b');
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(<span prop="a:3" />);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(null);
 
     ReactNoop.renderToRootWithID(<span prop="a:4" />, 'a');
     ReactNoop.renderToRootWithID(<BrokenRender label="b" />, 'b');
     ReactNoop.renderToRootWithID(<span prop="c:4" />, 'c');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('b');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForThrow('b');
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(<span prop="a:4" />);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(null);
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual(<span prop="c:4" />);
@@ -1132,10 +1119,8 @@ describe('ReactIncrementalErrorHandling', () => {
     ReactNoop.renderToRootWithID(<span prop="c:5" />, 'c');
     ReactNoop.renderToRootWithID(<span prop="d:5" />, 'd');
     ReactNoop.renderToRootWithID(<BrokenRender label="e" />, 'e');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('e');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForThrow('e');
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(<span prop="a:5" />);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(<span prop="b:5" />);
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual(<span prop="c:5" />);
@@ -1149,17 +1134,11 @@ describe('ReactIncrementalErrorHandling', () => {
     ReactNoop.renderToRootWithID(<BrokenRender label="e" />, 'e');
     ReactNoop.renderToRootWithID(<span prop="f:6" />, 'f');
 
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('a');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('c');
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrow('e');
+    await waitForThrow('a');
+    await waitForThrow('c');
+    await waitForThrow('e');
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(null);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(<span prop="b:6" />);
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual(null);
@@ -1173,7 +1152,7 @@ describe('ReactIncrementalErrorHandling', () => {
     ReactNoop.unmountRootWithID('d');
     ReactNoop.unmountRootWithID('e');
     ReactNoop.unmountRootWithID('f');
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(null);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(null);
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual(null);
@@ -1182,7 +1161,7 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(ReactNoop.getChildrenAsJSX('f')).toEqual(null);
   });
 
-  it('unwinds the context stack correctly on error', () => {
+  it('unwinds the context stack correctly on error', async () => {
     class Provider extends React.Component {
       static childContextTypes = {message: PropTypes.string};
       static contextTypes = {message: PropTypes.string};
@@ -1234,7 +1213,7 @@ describe('ReactIncrementalErrorHandling', () => {
         <Connector />
       </Provider>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     // If the context stack does not unwind, span will get 'abcde'
     expect(ReactNoop).toMatchRenderedOutput(<span prop="a" />);
@@ -1283,7 +1262,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('catches reconciler errors in a boundary during update', () => {
+  it('catches reconciler errors in a boundary during update', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -1307,7 +1286,7 @@ describe('ReactIncrementalErrorHandling', () => {
         <BrokenRender fail={false} />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     ReactNoop.render(
       <ErrorBoundary>
@@ -1334,7 +1313,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('recovers from uncaught reconciler errors', () => {
+  it('recovers from uncaught reconciler errors', async () => {
     const InvalidType = undefined;
     expect(() => ReactNoop.render(<InvalidType />)).toErrorDev(
       'Warning: React.createElement: type is invalid -- expected a string',
@@ -1350,11 +1329,11 @@ describe('ReactIncrementalErrorHandling', () => {
     );
 
     ReactNoop.render(<span prop="hi" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="hi" />);
   });
 
-  it('unmounts components with uncaught errors', () => {
+  it('unmounts components with uncaught errors', async () => {
     let inst;
 
     class BrokenRenderAndUnmount extends React.Component {
@@ -1390,14 +1369,21 @@ describe('ReactIncrementalErrorHandling', () => {
         </Parent>
       </Parent>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
-    inst.setState({fail: true});
     expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
-    }).toThrowError('Hello.');
+      expect(() => {
+        ReactNoop.flushSync(() => {
+          inst.setState({fail: true});
+        });
+      }).toThrow('Hello.');
+
+      // The unmount is queued in a microtask. In order to capture the error
+      // that occurs during unmount, we can flush it early with `flushSync`.
+      ReactNoop.flushSync();
+    }).toThrow('One does not simply unmount me.');
 
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       // Attempt to clean up.
       // Errors in parents shouldn't stop children from unmounting.
       'Parent componentWillUnmount [!]',
@@ -1405,13 +1391,9 @@ describe('ReactIncrementalErrorHandling', () => {
       'BrokenRenderAndUnmount componentWillUnmount',
     ]);
     expect(ReactNoop).toMatchRenderedOutput(null);
-
-    expect(() => {
-      ReactNoop.flushSync();
-    }).toThrow('One does not simply unmount me.');
   });
 
-  it('does not interrupt unmounting if detaching a ref throws', () => {
+  it('does not interrupt unmounting if detaching a ref throws', async () => {
     class Bar extends React.Component {
       componentWillUnmount() {
         Scheduler.unstable_yieldValue('Bar unmount');
@@ -1434,7 +1416,7 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['barRef attach']);
+    await waitForAll(['barRef attach']);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop="Bar" />
@@ -1444,7 +1426,7 @@ describe('ReactIncrementalErrorHandling', () => {
     // Unmount
     ReactNoop.render(<Foo hide={true} />);
     expect(Scheduler).toFlushAndThrow('Detach error');
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'barRef detach',
       // Bar should unmount even though its ref threw an error while detaching
       'Bar unmount',
@@ -1465,7 +1447,7 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(Scheduler).toFlushAndThrow('Error!');
   });
 
-  it('error boundaries capture non-errors', () => {
+  it('error boundaries capture non-errors', async () => {
     spyOnProd(console, 'error').mockImplementation(() => {});
     spyOnDev(console, 'error').mockImplementation(() => {});
 
@@ -1509,7 +1491,7 @@ describe('ReactIncrementalErrorHandling', () => {
       </ErrorBoundary>,
     );
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'ErrorBoundary (try)',
       'Indirection',
       'BadRender',
@@ -1540,7 +1522,7 @@ describe('ReactIncrementalErrorHandling', () => {
 
   // TODO: Error boundary does not catch promises
 
-  it('continues working on siblings of a component that throws', () => {
+  it('continues working on siblings of a component that throws', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -1580,7 +1562,7 @@ describe('ReactIncrementalErrorHandling', () => {
       </ErrorBoundary>,
     );
 
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'ErrorBoundary (try)',
       'throw',
       // Continue rendering siblings after BadRender throws
@@ -1603,7 +1585,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('calls the correct lifecycles on the error boundary after catching an error (mixed)', () => {
+  it('calls the correct lifecycles on the error boundary after catching an error (mixed)', async () => {
     // This test seems a bit contrived, but it's based on an actual regression
     // where we checked for the existence of didUpdate instead of didMount, and
     // didMount was not defined.
@@ -1632,7 +1614,7 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<Parent step={1} />);
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       'render',
       'throw',
       'render',
@@ -1646,7 +1628,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('provides component stack to the error boundary with componentDidCatch', () => {
+  it('provides component stack to the error boundary with componentDidCatch', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null, errorInfo: null};
       componentDidCatch(error, errorInfo) {
@@ -1676,7 +1658,7 @@ describe('ReactIncrementalErrorHandling', () => {
         <BrokenRender />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushAndYield(['render error message']);
+    await waitForAll(['render error message']);
     expect(ReactNoop).toMatchRenderedOutput(
       <span
         prop={
@@ -1688,7 +1670,7 @@ describe('ReactIncrementalErrorHandling', () => {
     );
   });
 
-  it('does not provide component stack to the error boundary with getDerivedStateFromError', () => {
+  it('does not provide component stack to the error boundary with getDerivedStateFromError', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       static getDerivedStateFromError(error, errorInfo) {
@@ -1712,13 +1694,13 @@ describe('ReactIncrementalErrorHandling', () => {
         <BrokenRender />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <span prop="Caught an error: Hello" />,
     );
   });
 
-  it('provides component stack even if overriding prepareStackTrace', () => {
+  it('provides component stack even if overriding prepareStackTrace', async () => {
     Error.prepareStackTrace = function (error, callsites) {
       const stack = ['An error occurred:', error.message];
       for (let i = 0; i < callsites.length; i++) {
@@ -1762,7 +1744,7 @@ describe('ReactIncrementalErrorHandling', () => {
         <BrokenRender />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushAndYield(['render error message']);
+    await waitForAll(['render error message']);
     Error.prepareStackTrace = undefined;
 
     expect(ReactNoop).toMatchRenderedOutput(
@@ -1822,7 +1804,7 @@ describe('ReactIncrementalErrorHandling', () => {
       });
 
       // Render past the component that throws, then yield.
-      expect(Scheduler).toFlushAndYieldThrough(['Oops']);
+      await waitFor(['Oops']);
       expect(root).toMatchRenderedOutput(null);
       // Interleaved update. When the root completes, instead of throwing the
       // error, it should try rendering again. This update will cause it to
@@ -1868,7 +1850,7 @@ describe('ReactIncrementalErrorHandling', () => {
 
       // Render through just the default pri update. The low pri update remains on
       // the queue.
-      expect(Scheduler).toFlushAndYieldThrough(['Everything is fine.']);
+      await waitFor(['Everything is fine.']);
 
       // Schedule a discrete update on a child that triggers an error.
       // The root should capture this error. But since there's still a pending
@@ -1878,7 +1860,7 @@ describe('ReactIncrementalErrorHandling', () => {
       });
     });
     // Should render the final state without throwing the error.
-    expect(Scheduler).toHaveYielded(['Everything is fine.']);
+    assertLog(['Everything is fine.']);
     expect(root).toMatchRenderedOutput('Everything is fine.');
   });
 
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
index 2a7fb8c78e157..165edacd01d36 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorLogging-test.js
@@ -13,6 +13,7 @@
 let React;
 let ReactNoop;
 let Scheduler;
+let waitForAll;
 
 describe('ReactIncrementalErrorLogging', () => {
   beforeEach(() => {
@@ -20,6 +21,9 @@ describe('ReactIncrementalErrorLogging', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
   });
 
   // Note: in this test file we won't be using toErrorDev() matchers
@@ -151,7 +155,7 @@ describe('ReactIncrementalErrorLogging', () => {
     }).toThrow('logCapturedError error');
   });
 
-  it('resets instance variables before unmounting failed node', () => {
+  it('resets instance variables before unmounting failed node', async () => {
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
@@ -185,7 +189,7 @@ describe('ReactIncrementalErrorLogging', () => {
         <Foo />
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushAndYield(
+    await waitForAll(
       [
         'render: 0',
 
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorReplay-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorReplay-test.js
index 6a9db6eada460..4f60e40efa23e 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorReplay-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorReplay-test.js
@@ -13,6 +13,7 @@
 let React;
 let ReactNoop;
 let Scheduler;
+let waitForAll;
 
 describe('ReactIncrementalErrorReplay', () => {
   beforeEach(() => {
@@ -20,6 +21,9 @@ describe('ReactIncrementalErrorReplay', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
   });
 
   it('should fail gracefully on error in the host environment', () => {
@@ -27,7 +31,7 @@ describe('ReactIncrementalErrorReplay', () => {
     expect(Scheduler).toFlushAndThrow('Error in host config.');
   });
 
-  it("should ignore error if it doesn't throw on retry", () => {
+  it("should ignore error if it doesn't throw on retry", async () => {
     let didInit = false;
 
     function badLazyInit() {
@@ -45,6 +49,6 @@ describe('ReactIncrementalErrorReplay', () => {
       }
     }
     ReactNoop.render(<App />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js
index 319be4c9f2b9f..cc0bcd9814864 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js
@@ -13,6 +13,8 @@
 let React;
 let ReactNoop;
 let Scheduler;
+let waitFor;
+let waitForAll;
 
 describe('ReactIncrementalReflection', () => {
   beforeEach(() => {
@@ -21,6 +23,10 @@ describe('ReactIncrementalReflection', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitFor = InternalTestUtils.waitFor;
+    waitForAll = InternalTestUtils.waitForAll;
   });
 
   function div(...children) {
@@ -34,7 +40,7 @@ describe('ReactIncrementalReflection', () => {
     return {type: 'span', children: [], prop, hidden: false};
   }
 
-  it('handles isMounted even when the initial render is deferred', () => {
+  it('handles isMounted even when the initial render is deferred', async () => {
     const instances = [];
 
     class Component extends React.Component {
@@ -68,17 +74,17 @@ describe('ReactIncrementalReflection', () => {
     });
 
     // Render part way through but don't yet commit the updates.
-    expect(Scheduler).toFlushAndYieldThrough(['componentWillMount: false']);
+    await waitFor(['componentWillMount: false']);
 
     expect(instances[0]._isMounted()).toBe(false);
 
     // Render the rest and commit the updates.
-    expect(Scheduler).toFlushAndYield(['componentDidMount: true']);
+    await waitForAll(['componentDidMount: true']);
 
     expect(instances[0]._isMounted()).toBe(true);
   });
 
-  it('handles isMounted when an unmount is deferred', () => {
+  it('handles isMounted when an unmount is deferred', async () => {
     const instances = [];
 
     class Component extends React.Component {
@@ -109,7 +115,7 @@ describe('ReactIncrementalReflection', () => {
     }
 
     ReactNoop.render(<Foo mount={true} />);
-    expect(Scheduler).toFlushAndYield(['Component']);
+    await waitForAll(['Component']);
 
     expect(instances[0]._isMounted()).toBe(true);
 
@@ -118,17 +124,17 @@ describe('ReactIncrementalReflection', () => {
     });
     // Render part way through but don't yet commit the updates so it is not
     // fully unmounted yet.
-    expect(Scheduler).toFlushAndYieldThrough(['Other']);
+    await waitFor(['Other']);
 
     expect(instances[0]._isMounted()).toBe(true);
 
     // Finish flushing the unmount.
-    expect(Scheduler).toFlushAndYield(['componentWillUnmount: true']);
+    await waitForAll(['componentWillUnmount: true']);
 
     expect(instances[0]._isMounted()).toBe(false);
   });
 
-  it('finds no node before insertion and correct node before deletion', () => {
+  it('finds no node before insertion and correct node before deletion', async () => {
     let classInstance = null;
 
     function findInstance(inst) {
@@ -202,18 +208,14 @@ describe('ReactIncrementalReflection', () => {
       ReactNoop.render(<Foo step={0} />);
     });
     // Flush past Component but don't complete rendering everything yet.
-    expect(Scheduler).toFlushAndYieldThrough([
-      ['componentWillMount', null],
-      'render',
-      'render sibling',
-    ]);
+    await waitFor([['componentWillMount', null], 'render', 'render sibling']);
 
     expect(classInstance).toBeDefined();
     // The instance has been complete but is still not committed so it should
     // not find any host nodes in it.
     expect(findInstance(classInstance)).toBe(null);
 
-    expect(Scheduler).toFlushAndYield([['componentDidMount', span()]]);
+    await waitForAll([['componentDidMount', span()]]);
 
     const hostSpan = classInstance.span;
     expect(hostSpan).toBeDefined();
@@ -223,7 +225,7 @@ describe('ReactIncrementalReflection', () => {
     // Flush next step which will cause an update but not yet render a new host
     // node.
     ReactNoop.render(<Foo step={1} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       ['componentWillUpdate', hostSpan],
       'render',
       'render sibling',
@@ -237,7 +239,7 @@ describe('ReactIncrementalReflection', () => {
     React.startTransition(() => {
       ReactNoop.render(<Foo step={2} />);
     });
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       ['componentWillUpdate', hostSpan],
       'render',
       'render sibling',
@@ -247,7 +249,7 @@ describe('ReactIncrementalReflection', () => {
     expect(ReactNoop.findInstance(classInstance)).toBe(hostSpan);
 
     // When we finally flush the tree it will get committed.
-    expect(Scheduler).toFlushAndYield([['componentDidUpdate', div()]]);
+    await waitForAll([['componentDidUpdate', div()]]);
 
     const hostDiv = classInstance.div;
     expect(hostDiv).toBeDefined();
@@ -260,7 +262,7 @@ describe('ReactIncrementalReflection', () => {
     React.startTransition(() => {
       ReactNoop.render(<Foo step={3} />);
     });
-    expect(Scheduler).toFlushAndYieldThrough([
+    await waitFor([
       ['componentWillUpdate', hostDiv],
       'render',
       'render sibling',
@@ -269,14 +271,14 @@ describe('ReactIncrementalReflection', () => {
     // This should still be the host div since the deletion is not committed.
     expect(ReactNoop.findInstance(classInstance)).toBe(hostDiv);
 
-    expect(Scheduler).toFlushAndYield([['componentDidUpdate', null]]);
+    await waitForAll([['componentDidUpdate', null]]);
 
     // This should still be the host div since the deletion is not committed.
     expect(ReactNoop.findInstance(classInstance)).toBe(null);
 
     // Render a div again
     ReactNoop.render(<Foo step={4} />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       ['componentWillUpdate', null],
       'render',
       'render sibling',
@@ -285,6 +287,6 @@ describe('ReactIncrementalReflection', () => {
 
     // Unmount the component.
     ReactNoop.render([]);
-    expect(Scheduler).toFlushAndYield([['componentWillUnmount', hostDiv]]);
+    await waitForAll([['componentWillUnmount', hostDiv]]);
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
index cfb09e497eb12..bed7b61e54528 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
@@ -14,6 +14,10 @@ let React;
 let ReactNoop;
 let Scheduler;
 let act;
+let waitForAll;
+let waitFor;
+let assertLog;
+let waitForPaint;
 
 describe('ReactIncrementalScheduling', () => {
   beforeEach(() => {
@@ -23,32 +27,38 @@ describe('ReactIncrementalScheduling', () => {
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
     act = require('jest-react').act;
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    assertLog = InternalTestUtils.assertLog;
+    waitForPaint = InternalTestUtils.waitForPaint;
   });
 
-  it('schedules and flushes deferred work', () => {
+  it('schedules and flushes deferred work', async () => {
     ReactNoop.render(<span prop="1" />);
     expect(ReactNoop).toMatchRenderedOutput(null);
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="1" />);
   });
 
-  it('searches for work on other roots once the current root completes', () => {
+  it('searches for work on other roots once the current root completes', async () => {
     ReactNoop.renderToRootWithID(<span prop="a:1" />, 'a');
     ReactNoop.renderToRootWithID(<span prop="b:1" />, 'b');
     ReactNoop.renderToRootWithID(<span prop="c:1" />, 'c');
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual(<span prop="a:1" />);
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual(<span prop="b:1" />);
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual(<span prop="c:1" />);
   });
 
-  it('schedules top-level updates in order of priority', () => {
+  it('schedules top-level updates in order of priority', async () => {
     // Initial render.
     ReactNoop.render(<span prop={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
 
     ReactNoop.batchedUpdates(() => {
@@ -64,14 +74,14 @@ describe('ReactIncrementalScheduling', () => {
 
     // The terminal value should be the last update that was scheduled,
     // regardless of priority. In this case, that's the last sync update.
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={4} />);
   });
 
-  it('schedules top-level updates with same priority in order of insertion', () => {
+  it('schedules top-level updates with same priority in order of insertion', async () => {
     // Initial render.
     ReactNoop.render(<span prop={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
 
     ReactNoop.render(<span prop={2} />);
@@ -79,7 +89,7 @@ describe('ReactIncrementalScheduling', () => {
     ReactNoop.render(<span prop={4} />);
     ReactNoop.render(<span prop={5} />);
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={5} />);
   });
 
@@ -97,20 +107,20 @@ describe('ReactIncrementalScheduling', () => {
       ReactNoop.renderToRootWithID(<Text text="b:1" />, 'b');
       ReactNoop.renderToRootWithID(<Text text="c:1" />, 'c');
     });
-    expect(Scheduler).toHaveYielded(['a:1', 'b:1', 'c:1']);
+    assertLog(['a:1', 'b:1', 'c:1']);
 
     expect(ReactNoop.getChildrenAsJSX('a')).toEqual('a:1');
     expect(ReactNoop.getChildrenAsJSX('b')).toEqual('b:1');
     expect(ReactNoop.getChildrenAsJSX('c')).toEqual('c:1');
 
     // Schedule deferred work in the reverse order
-    act(() => {
+    act(async () => {
       React.startTransition(() => {
         ReactNoop.renderToRootWithID(<Text text="c:2" />, 'c');
         ReactNoop.renderToRootWithID(<Text text="b:2" />, 'b');
       });
       // Ensure it starts in the order it was scheduled
-      expect(Scheduler).toFlushAndYieldThrough(['c:2']);
+      await waitFor(['c:2']);
 
       expect(ReactNoop.getChildrenAsJSX('a')).toEqual('a:1');
       expect(ReactNoop.getChildrenAsJSX('b')).toEqual('b:1');
@@ -122,19 +132,19 @@ describe('ReactIncrementalScheduling', () => {
       });
 
       // Keep performing work in the order it was scheduled
-      expect(Scheduler).toFlushAndYieldThrough(['b:2']);
+      await waitFor(['b:2']);
       expect(ReactNoop.getChildrenAsJSX('a')).toEqual('a:1');
       expect(ReactNoop.getChildrenAsJSX('b')).toEqual('b:2');
       expect(ReactNoop.getChildrenAsJSX('c')).toEqual('c:2');
 
-      expect(Scheduler).toFlushAndYieldThrough(['a:2']);
+      await waitFor(['a:2']);
       expect(ReactNoop.getChildrenAsJSX('a')).toEqual('a:2');
       expect(ReactNoop.getChildrenAsJSX('b')).toEqual('b:2');
       expect(ReactNoop.getChildrenAsJSX('c')).toEqual('c:2');
     });
   });
 
-  it('schedules sync updates when inside componentDidMount/Update', () => {
+  it('schedules sync updates when inside componentDidMount/Update', async () => {
     let instance;
 
     class Foo extends React.Component {
@@ -176,7 +186,7 @@ describe('ReactIncrementalScheduling', () => {
       ReactNoop.render(<Foo />);
     });
     // Render without committing
-    expect(Scheduler).toFlushAndYieldThrough(['render: 0']);
+    await waitFor(['render: 0']);
 
     // Do one more unit of work to commit
     expect(ReactNoop.flushNextYield()).toEqual([
@@ -191,7 +201,7 @@ describe('ReactIncrementalScheduling', () => {
     React.startTransition(() => {
       instance.setState({tick: 2});
     });
-    expect(Scheduler).toFlushAndYieldThrough(['render: 2']);
+    await waitFor(['render: 2']);
     expect(ReactNoop.flushNextYield()).toEqual([
       'componentDidUpdate: 2',
       'componentDidUpdate (before setState): 2',
@@ -203,7 +213,7 @@ describe('ReactIncrementalScheduling', () => {
     ]);
   });
 
-  it('can opt-in to async scheduling inside componentDidMount/Update', () => {
+  it('can opt-in to async scheduling inside componentDidMount/Update', async () => {
     let instance;
     class Foo extends React.Component {
       state = {tick: 0};
@@ -248,7 +258,7 @@ describe('ReactIncrementalScheduling', () => {
       ReactNoop.render(<Foo />);
     });
     // The cDM update should not have flushed yet because it has async priority.
-    expect(Scheduler).toHaveYielded([
+    assertLog([
       'render: 0',
       'componentDidMount (before setState): 0',
       'componentDidMount (after setState): 0',
@@ -256,14 +266,14 @@ describe('ReactIncrementalScheduling', () => {
     expect(ReactNoop).toMatchRenderedOutput(<span prop={0} />);
 
     // Now flush the cDM update.
-    expect(Scheduler).toFlushAndYield(['render: 1', 'componentDidUpdate: 1']);
+    await waitForAll(['render: 1', 'componentDidUpdate: 1']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
 
     React.startTransition(() => {
       instance.setState({tick: 2});
     });
 
-    expect(Scheduler).toFlushUntilNextPaint([
+    await waitForPaint([
       'render: 2',
       'componentDidUpdate: 2',
       'componentDidUpdate (before setState): 2',
@@ -272,11 +282,11 @@ describe('ReactIncrementalScheduling', () => {
     expect(ReactNoop).toMatchRenderedOutput(<span prop={2} />);
 
     // Now flush the cDU update.
-    expect(Scheduler).toFlushAndYield(['render: 3', 'componentDidUpdate: 3']);
+    await waitForAll(['render: 3', 'componentDidUpdate: 3']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={3} />);
   });
 
-  it('performs Task work even after time runs out', () => {
+  it('performs Task work even after time runs out', async () => {
     class Foo extends React.Component {
       state = {step: 1};
       componentDidMount() {
@@ -299,7 +309,7 @@ describe('ReactIncrementalScheduling', () => {
 
     // This should be just enough to complete all the work, but not enough to
     // commit it.
-    expect(Scheduler).toFlushAndYieldThrough(['Foo']);
+    await waitFor(['Foo']);
     expect(ReactNoop).toMatchRenderedOutput(null);
 
     // Do one more unit of work.
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js
index fd1361de82205..4c20424e2e7e1 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js
@@ -13,6 +13,8 @@
 let React;
 let ReactNoop;
 let Scheduler;
+let waitForAll;
+let waitFor;
 
 describe('ReactIncrementalSideEffects', () => {
   beforeEach(() => {
@@ -21,6 +23,10 @@ describe('ReactIncrementalSideEffects', () => {
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
   });
 
   // Note: This is based on a similar component we use in www. We can delete
@@ -36,7 +42,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
   }
 
-  it('can update child nodes of a host instance', () => {
+  it('can update child nodes of a host instance', async () => {
     function Bar(props) {
       return <span>{props.text}</span>;
     }
@@ -51,7 +57,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo text="Hello" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span>Hello</span>
@@ -59,7 +65,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(<Foo text="World" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span>World</span>
@@ -68,7 +74,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
   });
 
-  it('can update child nodes of a fragment', function () {
+  it('can update child nodes of a fragment', async function () {
     function Bar(props) {
       return <span>{props.text}</span>;
     }
@@ -88,7 +94,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo text="Hello" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span>Hello</span>
@@ -97,7 +103,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(<Foo text="World" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span>World</span>
@@ -108,7 +114,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(<Foo text="Hi" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span>Hi</span>
@@ -119,7 +125,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
   });
 
-  it('can update child nodes rendering into text nodes', function () {
+  it('can update child nodes rendering into text nodes', async function () {
     function Bar(props) {
       return props.text;
     }
@@ -136,15 +142,15 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo text="Hello" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div>Hello</div>);
 
     ReactNoop.render(<Foo text="World" />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div>WorldWorld!</div>);
   });
 
-  it('can deletes children either components, host or text', function () {
+  it('can deletes children either components, host or text', async function () {
     function Bar(props) {
       return <span prop={props.children} />;
     }
@@ -160,7 +166,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo show={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <div />
@@ -170,11 +176,11 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(<Foo show={false} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div />);
   });
 
-  it('can delete a child that changes type - implicit keys', function () {
+  it('can delete a child that changes type - implicit keys', async function () {
     let unmounted = false;
 
     class ClassComponent extends React.Component {
@@ -206,7 +212,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo useClass={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop="Class" />
@@ -217,7 +223,7 @@ describe('ReactIncrementalSideEffects', () => {
     expect(unmounted).toBe(false);
 
     ReactNoop.render(<Foo useFunction={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop="Function" />
@@ -228,15 +234,15 @@ describe('ReactIncrementalSideEffects', () => {
     expect(unmounted).toBe(true);
 
     ReactNoop.render(<Foo useText={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div>TextTrail</div>);
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div>Trail</div>);
   });
 
-  it('can delete a child that changes type - explicit keys', function () {
+  it('can delete a child that changes type - explicit keys', async function () {
     let unmounted = false;
 
     class ClassComponent extends React.Component {
@@ -266,7 +272,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo useClass={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop="Class" />
@@ -277,7 +283,7 @@ describe('ReactIncrementalSideEffects', () => {
     expect(unmounted).toBe(false);
 
     ReactNoop.render(<Foo useFunction={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop="Function" />
@@ -288,11 +294,11 @@ describe('ReactIncrementalSideEffects', () => {
     expect(unmounted).toBe(true);
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div>Trail</div>);
   });
 
-  it('can delete a child when it unmounts inside a portal', () => {
+  it('can delete a child when it unmounts inside a portal', async () => {
     function Bar(props) {
       return <span prop={props.children} />;
     }
@@ -312,7 +318,7 @@ describe('ReactIncrementalSideEffects', () => {
         <Foo show={true} />
       </div>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div />);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(
       <>
@@ -327,7 +333,7 @@ describe('ReactIncrementalSideEffects', () => {
         <Foo show={false} />
       </div>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div />);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
 
@@ -336,7 +342,7 @@ describe('ReactIncrementalSideEffects', () => {
         <Foo show={true} />
       </div>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div />);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(
       <>
@@ -347,17 +353,17 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(null);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
 
     ReactNoop.render(<Foo show={false} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
 
     ReactNoop.render(<Foo show={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(
       <>
@@ -368,12 +374,12 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(null);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
   });
 
-  it('can delete a child when it unmounts with a portal', () => {
+  it('can delete a child when it unmounts with a portal', async () => {
     function Bar(props) {
       return <span prop={props.children} />;
     }
@@ -393,7 +399,7 @@ describe('ReactIncrementalSideEffects', () => {
         <Foo />
       </div>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<div />);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(
       <>
@@ -404,12 +410,12 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(null);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(
       <>
@@ -420,12 +426,12 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(null);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(null);
     expect(ReactNoop.getChildrenAsJSX('portalContainer')).toEqual(null);
   });
 
-  it('does not update child nodes if a flush is aborted', () => {
+  it('does not update child nodes if a flush is aborted', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <span prop={props.text} />;
@@ -445,7 +451,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo text="Hello" />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar', 'Bar']);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <div>
@@ -461,7 +467,7 @@ describe('ReactIncrementalSideEffects', () => {
     });
 
     // Flush some of the work without committing
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Bar']);
+    await waitFor(['Foo', 'Bar']);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <div>
@@ -474,7 +480,7 @@ describe('ReactIncrementalSideEffects', () => {
   });
 
   // @gate www
-  it('preserves a previously rendered node when deprioritized', () => {
+  it('preserves a previously rendered node when deprioritized', async () => {
     function Middle(props) {
       Scheduler.unstable_yieldValue('Middle');
       return <span prop={props.children} />;
@@ -492,7 +498,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo text="foo" />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Middle']);
+    await waitForAll(['Foo', 'Middle']);
 
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
@@ -505,7 +511,7 @@ describe('ReactIncrementalSideEffects', () => {
     ReactNoop.render(<Foo text="bar" />, () =>
       Scheduler.unstable_yieldValue('commit'),
     );
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'commit']);
+    await waitFor(['Foo', 'commit']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         <div hidden={true}>
@@ -514,7 +520,7 @@ describe('ReactIncrementalSideEffects', () => {
       </div>,
     );
 
-    expect(Scheduler).toFlushAndYield(['Middle']);
+    await waitForAll(['Middle']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         <div hidden={true}>
@@ -525,7 +531,7 @@ describe('ReactIncrementalSideEffects', () => {
   });
 
   // @gate www
-  it('can reuse side-effects after being preempted', () => {
+  it('can reuse side-effects after being preempted', async () => {
     function Bar(props) {
       Scheduler.unstable_yieldValue('Bar');
       return <span prop={props.children} />;
@@ -556,7 +562,7 @@ describe('ReactIncrementalSideEffects', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" step={0} />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar']);
 
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div hidden={true}>
@@ -572,7 +578,7 @@ describe('ReactIncrementalSideEffects', () => {
     ReactNoop.render(<Foo text="bar" step={1} />, () =>
       Scheduler.unstable_yieldValue('commit'),
     );
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'commit', 'Bar']);
+    await waitFor(['Foo', 'commit', 'Bar']);
 
     // The tree remains unchanged.
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
@@ -588,7 +594,7 @@ describe('ReactIncrementalSideEffects', () => {
     // render some higher priority work. The middle content will bailout so
     // it remains untouched which means that it should reuse it next time.
     ReactNoop.render(<Foo text="foo" step={1} />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar']);
 
     // Since we did nothing to the middle subtree during the interruption,
     // we should be able to reuse the reconciliation work that we already did
@@ -605,7 +611,7 @@ describe('ReactIncrementalSideEffects', () => {
   });
 
   // @gate www
-  it('can reuse side-effects after being preempted, if shouldComponentUpdate is false', () => {
+  it('can reuse side-effects after being preempted, if shouldComponentUpdate is false', async () => {
     class Bar extends React.Component {
       shouldComponentUpdate(nextProps) {
         return this.props.children !== nextProps.children;
@@ -642,7 +648,7 @@ describe('ReactIncrementalSideEffects', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" step={0} />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Content', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Content', 'Bar', 'Bar']);
 
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div hidden={true}>
@@ -656,7 +662,7 @@ describe('ReactIncrementalSideEffects', () => {
     // Make a quick update which will schedule low priority work to
     // update the middle content.
     ReactNoop.render(<Foo text="bar" step={1} />);
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Content', 'Bar']);
+    await waitFor(['Foo', 'Content', 'Bar']);
 
     // The tree remains unchanged.
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
@@ -672,7 +678,7 @@ describe('ReactIncrementalSideEffects', () => {
     // render some higher priority work. The middle content will bailout so
     // it remains untouched which means that it should reuse it next time.
     ReactNoop.render(<Foo text="foo" step={1} />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Content', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Content', 'Bar', 'Bar']);
 
     // Since we did nothing to the middle subtree during the interruption,
     // we should be able to reuse the reconciliation work that we already did
@@ -688,7 +694,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
   });
 
-  it('can update a completed tree before it has a chance to commit', () => {
+  it('can update a completed tree before it has a chance to commit', async () => {
     function Foo(props) {
       Scheduler.unstable_yieldValue('Foo');
       return <span prop={props.step} />;
@@ -697,7 +703,7 @@ describe('ReactIncrementalSideEffects', () => {
       ReactNoop.render(<Foo step={1} />);
     });
     // This should be just enough to complete the tree without committing it
-    expect(Scheduler).toFlushAndYieldThrough(['Foo']);
+    await waitFor(['Foo']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(null);
     // To confirm, perform one more unit of work. The tree should now
     // be flushed.
@@ -708,7 +714,7 @@ describe('ReactIncrementalSideEffects', () => {
       ReactNoop.render(<Foo step={2} />);
     });
     // This should be just enough to complete the tree without committing it
-    expect(Scheduler).toFlushAndYieldThrough(['Foo']);
+    await waitFor(['Foo']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(<span prop={1} />);
     // This time, before we commit the tree, we update the root component with
     // new props
@@ -723,12 +729,12 @@ describe('ReactIncrementalSideEffects', () => {
     expect(ReactNoop.getChildrenAsJSX()).toEqual(<span prop={2} />);
     // If we flush the rest of the work, we should get another commit that
     // renders 3. If it renders 2 again, that means an update was dropped.
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(<span prop={3} />);
   });
 
   // @gate www
-  it('updates a child even though the old props is empty', () => {
+  it('updates a child even though the old props is empty', async () => {
     function Foo(props) {
       return (
         <LegacyHiddenDiv mode="hidden">
@@ -738,7 +744,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div hidden={true}>
         <span prop={1} />
@@ -746,7 +752,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
   });
 
-  xit('can defer side-effects and resume them later on', () => {
+  xit('can defer side-effects and resume them later on', async () => {
     class Bar extends React.Component {
       shouldComponentUpdate(nextProps) {
         return this.props.idx !== nextProps.idx;
@@ -809,7 +815,7 @@ describe('ReactIncrementalSideEffects', () => {
       </div>,
     );
     ReactNoop.render(<Foo tick={3} idx={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(
       <div>
         <span prop={3} />
@@ -829,7 +835,7 @@ describe('ReactIncrementalSideEffects', () => {
     expect(innerSpanA).toBe(innerSpanB);
   });
 
-  xit('can defer side-effects and reuse them later - complex', function () {
+  xit('can defer side-effects and reuse them later - complex', async function () {
     let ops = [];
 
     class Bar extends React.Component {
@@ -892,7 +898,7 @@ describe('ReactIncrementalSideEffects', () => {
     expect(ops).toEqual(['Foo']);
     ops = [];
 
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput([
       <div>
         <span prop={1} />,
@@ -959,7 +965,7 @@ describe('ReactIncrementalSideEffects', () => {
 
     // We should now be able to reuse some of the work we've already done
     // and replay those side-effects.
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput([
       <div>
         <span prop={3} />,
@@ -979,7 +985,7 @@ describe('ReactIncrementalSideEffects', () => {
   });
 
   // @gate www
-  it('deprioritizes setStates that happens within a deprioritized tree', () => {
+  it('deprioritizes setStates that happens within a deprioritized tree', async () => {
     const barInstances = [];
 
     class Bar extends React.Component {
@@ -1010,7 +1016,7 @@ describe('ReactIncrementalSideEffects', () => {
       );
     }
     ReactNoop.render(<Foo tick={0} idx={0} />);
-    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar', 'Bar']);
+    await waitForAll(['Foo', 'Bar', 'Bar', 'Bar']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         <span prop={0} />
@@ -1023,7 +1029,7 @@ describe('ReactIncrementalSideEffects', () => {
     );
 
     ReactNoop.render(<Foo tick={1} idx={1} />);
-    expect(Scheduler).toFlushAndYieldThrough(['Foo', 'Bar', 'Bar']);
+    await waitFor(['Foo', 'Bar', 'Bar']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         {/* Updated */}
@@ -1041,7 +1047,7 @@ describe('ReactIncrementalSideEffects', () => {
     // This should not be enough time to render the content of all the hidden
     // items. Including the set state since that is deprioritized.
     // ReactNoop.flushDeferredPri(35);
-    expect(Scheduler).toFlushAndYieldThrough(['Bar']);
+    await waitFor(['Bar']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         {/* Updated */}
@@ -1057,7 +1063,7 @@ describe('ReactIncrementalSideEffects', () => {
 
     // However, once we render fully, we will have enough time to finish it all
     // at once.
-    expect(Scheduler).toFlushAndYield(['Bar', 'Bar']);
+    await waitForAll(['Bar', 'Bar']);
     expect(ReactNoop.getChildrenAsJSX()).toEqual(
       <div>
         <span prop={1} />
@@ -1074,7 +1080,7 @@ describe('ReactIncrementalSideEffects', () => {
   // moves to "current" without flushing due to having lower priority. Does this
   // even happen? Maybe a child doesn't get processed because it is lower prio?
 
-  it('calls callback after update is flushed', () => {
+  it('calls callback after update is flushed', async () => {
     let instance;
     class Foo extends React.Component {
       constructor() {
@@ -1088,18 +1094,18 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="foo" />);
     let called = false;
     instance.setState({text: 'bar'}, () => {
       expect(ReactNoop).toMatchRenderedOutput(<span prop="bar" />);
       called = true;
     });
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(called).toBe(true);
   });
 
-  it('calls setState callback even if component bails out', () => {
+  it('calls setState callback even if component bails out', async () => {
     let instance;
     class Foo extends React.Component {
       constructor() {
@@ -1116,19 +1122,19 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="foo" />);
     let called = false;
     instance.setState({}, () => {
       called = true;
     });
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(called).toBe(true);
   });
 
   // TODO: Test that callbacks are not lost if an update is preempted.
 
-  it('calls componentWillUnmount after a deletion, even if nested', () => {
+  it('calls componentWillUnmount after a deletion, even if nested', async () => {
     const ops = [];
 
     class Bar extends React.Component {
@@ -1170,11 +1176,11 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo show={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([]);
 
     ReactNoop.render(<Foo show={false} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([
       'A',
       'Wrapper',
@@ -1188,7 +1194,7 @@ describe('ReactIncrementalSideEffects', () => {
     ]);
   });
 
-  it('calls componentDidMount/Update after insertion/update', () => {
+  it('calls componentDidMount/Update after insertion/update', async () => {
     let ops = [];
 
     class Bar extends React.Component {
@@ -1233,7 +1239,7 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([
       'mount:A',
       'mount:B',
@@ -1249,7 +1255,7 @@ describe('ReactIncrementalSideEffects', () => {
     ops = [];
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([
       'update:A',
       'update:B',
@@ -1263,7 +1269,7 @@ describe('ReactIncrementalSideEffects', () => {
     ]);
   });
 
-  it('invokes ref callbacks after insertion/update/unmount', () => {
+  it('invokes ref callbacks after insertion/update/unmount', async () => {
     let classInstance = null;
 
     let ops = [];
@@ -1310,7 +1316,7 @@ describe('ReactIncrementalSideEffects', () => {
 
     // Refs that switch function instances get reinvoked
     ReactNoop.render(<Foo show={true} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([
       // detach all refs that switched handlers first.
       null,
@@ -1323,7 +1329,7 @@ describe('ReactIncrementalSideEffects', () => {
     ops = [];
 
     ReactNoop.render(<Foo show={false} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(ops).toEqual([
       // unmount
       null,
@@ -1334,7 +1340,7 @@ describe('ReactIncrementalSideEffects', () => {
   // TODO: Test that mounts, updates, refs, unmounts and deletions happen in the
   // expected way for aborted and resumed render life-cycles.
 
-  it('supports string refs', () => {
+  it('supports string refs', async () => {
     let fooInstance = null;
 
     class Bar extends React.Component {
@@ -1354,8 +1360,8 @@ describe('ReactIncrementalSideEffects', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
+    await expect(async () => {
+      await waitForAll([]);
     }).toErrorDev([
       'Warning: Component "Foo" contains the string ref "bar". ' +
         'Support for string refs will be removed in a future major release. ' +
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js b/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
index de60712c11665..3c548469fb67a 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
@@ -15,6 +15,9 @@ let ReactNoop;
 let Scheduler;
 let ContinuousEventPriority;
 let act;
+let waitForAll;
+let waitFor;
+let assertLog;
 
 describe('ReactIncrementalUpdates', () => {
   beforeEach(() => {
@@ -26,6 +29,11 @@ describe('ReactIncrementalUpdates', () => {
     act = require('jest-react').act;
     ContinuousEventPriority =
       require('react-reconciler/constants').ContinuousEventPriority;
+
+    const InternalTestUtils = require('internal-test-utils');
+    waitForAll = InternalTestUtils.waitForAll;
+    waitFor = InternalTestUtils.waitFor;
+    assertLog = InternalTestUtils.assertLog;
   });
 
   function flushNextRenderIfExpired() {
@@ -37,7 +45,7 @@ describe('ReactIncrementalUpdates', () => {
     ReactNoop.flushSync();
   }
 
-  it('applies updates in order of priority', () => {
+  it('applies updates in order of priority', async () => {
     let state;
     class Foo extends React.Component {
       state = {};
@@ -58,14 +66,14 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYieldThrough(['commit']);
+    await waitFor(['commit']);
 
     expect(state).toEqual({a: 'a'});
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(state).toEqual({a: 'a', b: 'b', c: 'c'});
   });
 
-  it('applies updates with equal priority in insertion order', () => {
+  it('applies updates with equal priority in insertion order', async () => {
     let state;
     class Foo extends React.Component {
       state = {};
@@ -82,11 +90,11 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(state).toEqual({a: 'a', b: 'b', c: 'c'});
   });
 
-  it('only drops updates with equal or lesser priority when replaceState is called', () => {
+  it('only drops updates with equal or lesser priority when replaceState is called', async () => {
     let instance;
     class Foo extends React.Component {
       state = {};
@@ -104,7 +112,7 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['render', 'componentDidMount']);
+    await waitForAll(['render', 'componentDidMount']);
 
     ReactNoop.flushSync(() => {
       React.startTransition(() => {
@@ -122,14 +130,14 @@ describe('ReactIncrementalUpdates', () => {
     // Even though a replaceState has been already scheduled, it hasn't been
     // flushed yet because it has async priority.
     expect(instance.state).toEqual({a: 'a', b: 'b'});
-    expect(Scheduler).toHaveYielded(['render', 'componentDidUpdate']);
+    assertLog(['render', 'componentDidUpdate']);
 
-    expect(Scheduler).toFlushAndYield(['render', 'componentDidUpdate']);
+    await waitForAll(['render', 'componentDidUpdate']);
     // Now the rest of the updates are flushed, including the replaceState.
     expect(instance.state).toEqual({c: 'c', d: 'd'});
   });
 
-  it('can abort an update, schedule additional updates, and resume', () => {
+  it('can abort an update, schedule additional updates, and resume', async () => {
     let instance;
     class Foo extends React.Component {
       state = {};
@@ -140,7 +148,7 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     function createUpdate(letter) {
       return () => {
@@ -159,7 +167,7 @@ describe('ReactIncrementalUpdates', () => {
     });
 
     // Begin the updates but don't flush them yet
-    expect(Scheduler).toFlushAndYieldThrough(['a', 'b', 'c']);
+    await waitFor(['a', 'b', 'c']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="" />);
 
     // Schedule some more updates at different priorities
@@ -174,11 +182,11 @@ describe('ReactIncrementalUpdates', () => {
 
     // The sync updates should have flushed, but not the async ones.
     if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
+      assertLog(['d', 'e', 'f']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="def" />);
     } else {
       // Update d was dropped and replaced by e.
-      expect(Scheduler).toHaveYielded(['e', 'f']);
+      assertLog(['e', 'f']);
       expect(ReactNoop).toMatchRenderedOutput(<span prop="ef" />);
     }
 
@@ -186,7 +194,7 @@ describe('ReactIncrementalUpdates', () => {
     // they should be processed again, to ensure that the terminal state
     // is deterministic.
     if (gate(flags => !flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Since 'g' is in a transition, we'll process 'd' separately first.
         // That causes us to process 'd' with 'e' and 'f' rebased.
         'd',
@@ -202,7 +210,7 @@ describe('ReactIncrementalUpdates', () => {
         'g',
       ]);
     } else {
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Then we'll re-process everything for 'g'.
         'a',
         'b',
@@ -216,7 +224,7 @@ describe('ReactIncrementalUpdates', () => {
     expect(ReactNoop).toMatchRenderedOutput(<span prop="abcdefg" />);
   });
 
-  it('can abort an update, schedule a replaceState, and resume', () => {
+  it('can abort an update, schedule a replaceState, and resume', async () => {
     let instance;
     class Foo extends React.Component {
       state = {};
@@ -227,7 +235,7 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     function createUpdate(letter) {
       return () => {
@@ -246,7 +254,7 @@ describe('ReactIncrementalUpdates', () => {
     });
 
     // Begin the updates but don't flush them yet
-    expect(Scheduler).toFlushAndYieldThrough(['a', 'b', 'c']);
+    await waitFor(['a', 'b', 'c']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop="" />);
 
     // Schedule some more updates at different priorities
@@ -264,10 +272,10 @@ describe('ReactIncrementalUpdates', () => {
 
     // The sync updates should have flushed, but not the async ones.
     if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded(['d', 'e', 'f']);
+      assertLog(['d', 'e', 'f']);
     } else {
       // Update d was dropped and replaced by e.
-      expect(Scheduler).toHaveYielded(['e', 'f']);
+      assertLog(['e', 'f']);
     }
     expect(ReactNoop).toMatchRenderedOutput(<span prop="f" />);
 
@@ -275,7 +283,7 @@ describe('ReactIncrementalUpdates', () => {
     // they should be processed again, to ensure that the terminal state
     // is deterministic.
     if (gate(flags => !flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Since 'g' is in a transition, we'll process 'd' separately first.
         // That causes us to process 'd' with 'e' and 'f' rebased.
         'd',
@@ -291,7 +299,7 @@ describe('ReactIncrementalUpdates', () => {
         'g',
       ]);
     } else {
-      expect(Scheduler).toFlushAndYield([
+      await waitForAll([
         // Then we'll re-process everything for 'g'.
         'a',
         'b',
@@ -305,7 +313,7 @@ describe('ReactIncrementalUpdates', () => {
     expect(ReactNoop).toMatchRenderedOutput(<span prop="fg" />);
   });
 
-  it('passes accumulation of previous updates to replaceState updater function', () => {
+  it('passes accumulation of previous updates to replaceState updater function', async () => {
     let instance;
     class Foo extends React.Component {
       state = {};
@@ -315,7 +323,7 @@ describe('ReactIncrementalUpdates', () => {
       }
     }
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
 
     instance.setState({a: 'a'});
     instance.setState({b: 'b'});
@@ -324,11 +332,11 @@ describe('ReactIncrementalUpdates', () => {
     instance.updater.enqueueReplaceState(instance, previousState => ({
       previousState,
     }));
-    expect(Scheduler).toFlushWithoutYielding();
+    await waitForAll([]);
     expect(instance.state).toEqual({previousState: {a: 'a', b: 'b'}});
   });
 
-  it('does not call callbacks that are scheduled by another callback until a later commit', () => {
+  it('does not call callbacks that are scheduled by another callback until a later commit', async () => {
     class Foo extends React.Component {
       state = {};
       componentDidMount() {
@@ -347,7 +355,7 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       'render',
       'did mount',
       'render',
@@ -357,7 +365,7 @@ describe('ReactIncrementalUpdates', () => {
     ]);
   });
 
-  it('gives setState during reconciliation the same priority as whatever level is currently reconciling', () => {
+  it('gives setState during reconciliation the same priority as whatever level is currently reconciling', async () => {
     let instance;
 
     class Foo extends React.Component {
@@ -373,7 +381,7 @@ describe('ReactIncrementalUpdates', () => {
       }
     }
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield(['render']);
+    await waitForAll(['render']);
 
     ReactNoop.flushSync(() => {
       instance.setState({a: 'a'});
@@ -384,17 +392,13 @@ describe('ReactIncrementalUpdates', () => {
     expect(instance.state).toEqual({a: 'a', b: 'b'});
 
     if (gate(flags => flags.deferRenderPhaseUpdateToNextBatch)) {
-      expect(Scheduler).toHaveYielded([
-        'componentWillReceiveProps',
-        'render',
-        'render',
-      ]);
+      assertLog(['componentWillReceiveProps', 'render', 'render']);
     } else {
-      expect(Scheduler).toHaveYielded(['componentWillReceiveProps', 'render']);
+      assertLog(['componentWillReceiveProps', 'render']);
     }
   });
 
-  it('updates triggered from inside a class setState updater', () => {
+  it('updates triggered from inside a class setState updater', async () => {
     let instance;
     class Foo extends React.Component {
       state = {};
@@ -406,7 +410,7 @@ describe('ReactIncrementalUpdates', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushAndYield([
+    await waitForAll([
       // Initial render
       'render',
     ]);
@@ -451,7 +455,7 @@ describe('ReactIncrementalUpdates', () => {
       this.setState({a: 'a'});
       return {b: 'b'};
     });
-    expect(Scheduler).toFlushAndYield(
+    await waitForAll(
       gate(flags =>
         flags.deferRenderPhaseUpdateToNextBatch
           ? // In the new reconciler, updates inside the render phase are
@@ -529,24 +533,20 @@ describe('ReactIncrementalUpdates', () => {
       return null;
     }
 
-    act(() => {
+    act(async () => {
       React.startTransition(() => {
         ReactNoop.render(<App />);
       });
       flushNextRenderIfExpired();
-      expect(Scheduler).toHaveYielded([]);
-      expect(Scheduler).toFlushAndYield([
-        'Render: 0',
-        'Commit: 0',
-        'Render: 1',
-      ]);
+      assertLog([]);
+      await waitForAll(['Render: 0', 'Commit: 0', 'Render: 1']);
 
       Scheduler.unstable_advanceTime(10000);
       React.startTransition(() => {
         setCount(2);
       });
       flushNextRenderIfExpired();
-      expect(Scheduler).toHaveYielded([]);
+      assertLog([]);
     });
   });
 
@@ -559,7 +559,7 @@ describe('ReactIncrementalUpdates', () => {
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Text text="A" />);
     });
-    expect(Scheduler).toHaveYielded(['A']);
+    assertLog(['A']);
 
     Scheduler.unstable_advanceTime(10000);
 
@@ -567,7 +567,7 @@ describe('ReactIncrementalUpdates', () => {
       ReactNoop.render(<Text text="B" />);
     });
     flushNextRenderIfExpired();
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
   });
 
   it('regression: does not expire soon due to previous expired work', () => {
@@ -581,7 +581,7 @@ describe('ReactIncrementalUpdates', () => {
     });
     Scheduler.unstable_advanceTime(10000);
     flushNextRenderIfExpired();
-    expect(Scheduler).toHaveYielded(['A']);
+    assertLog(['A']);
 
     Scheduler.unstable_advanceTime(10000);
 
@@ -589,7 +589,7 @@ describe('ReactIncrementalUpdates', () => {
       ReactNoop.render(<Text text="B" />);
     });
     flushNextRenderIfExpired();
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
   });
 
   it('when rebasing, does not exclude updates that were already committed, regardless of priority', async () => {
@@ -620,7 +620,7 @@ describe('ReactIncrementalUpdates', () => {
     await act(async () => {
       root.render(<App />);
     });
-    expect(Scheduler).toHaveYielded(['Committed: ']);
+    assertLog(['Committed: ']);
     expect(root).toMatchRenderedOutput(null);
 
     await act(async () => {
@@ -633,13 +633,9 @@ describe('ReactIncrementalUpdates', () => {
       );
     });
     if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded([
-        'Committed: B',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
+      assertLog(['Committed: B', 'Committed: BCD', 'Committed: ABCD']);
     } else {
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // A and B are pending. B is higher priority, so we'll render that first.
         'Committed: B',
         // Because A comes first in the queue, we're now in rebase mode. B must
@@ -685,7 +681,7 @@ describe('ReactIncrementalUpdates', () => {
     await act(async () => {
       root.render(<App />);
     });
-    expect(Scheduler).toHaveYielded([]);
+    assertLog([]);
     expect(root).toMatchRenderedOutput(null);
 
     await act(async () => {
@@ -697,13 +693,9 @@ describe('ReactIncrementalUpdates', () => {
       );
     });
     if (gate(flags => flags.enableUnifiedSyncLane)) {
-      expect(Scheduler).toHaveYielded([
-        'Committed: B',
-        'Committed: BCD',
-        'Committed: ABCD',
-      ]);
+      assertLog(['Committed: B', 'Committed: BCD', 'Committed: ABCD']);
     } else {
-      expect(Scheduler).toHaveYielded([
+      assertLog([
         // A and B are pending. B is higher priority, so we'll render that first.
         'Committed: B',
         // Because A comes first in the queue, we're now in rebase mode. B must
diff --git a/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js b/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js
index 89d9de5226d9e..709a30e6b035d 100644
--- a/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactInterleavedUpdates-test.js
@@ -5,6 +5,9 @@ let startTransition;
 let useState;
 let useEffect;
 let act;
+let assertLog;
+let waitFor;
+let waitForPaint;
 
 describe('ReactInterleavedUpdates', () => {
   beforeEach(() => {
@@ -17,6 +20,11 @@ describe('ReactInterleavedUpdates', () => {
     startTransition = React.startTransition;
     useState = React.useState;
     useEffect = React.useEffect;
+
+    const InternalTestUtils = require('internal-test-utils');
+    assertLog = InternalTestUtils.assertLog;
+    waitFor = InternalTestUtils.waitFor;
+    waitForPaint = InternalTestUtils.waitForPaint;
   });
 
   function Text({text}) {
@@ -53,7 +61,7 @@ describe('ReactInterleavedUpdates', () => {
         </>,
       );
     });
-    expect(Scheduler).toHaveYielded([0, 0, 0]);
+    assertLog([0, 0, 0]);
     expect(root).toMatchRenderedOutput('000');
 
     await act(async () => {
@@ -61,7 +69,7 @@ describe('ReactInterleavedUpdates', () => {
         updateChildren(1);
       });
       // Partially render the children. Only the first one.
-      expect(Scheduler).toFlushAndYieldThrough([1]);
+      await waitFor([1]);
 
       // In an interleaved event, schedule an update on each of the children.
       // Including the two that haven't rendered yet.
@@ -70,11 +78,11 @@ describe('ReactInterleavedUpdates', () => {
       });
 
       // We should continue rendering without including the interleaved updates.
-      expect(Scheduler).toFlushUntilNextPaint([1, 1]);
+      await waitForPaint([1, 1]);
       expect(root).toMatchRenderedOutput('111');
     });
     // The interleaved updates flush in a separate render.
-    expect(Scheduler).toHaveYielded([2, 2, 2]);
+    assertLog([2, 2, 2]);
     expect(root).toMatchRenderedOutput('222');
   });
 
@@ -96,7 +104,7 @@ describe('ReactInterleavedUpdates', () => {
     await act(async () => {
       root.render(<App />);
     });
-    expect(Scheduler).toHaveYielded(['A0', 'B0', 'C0']);
+    assertLog(['A0', 'B0', 'C0']);
     expect(root).toMatchRenderedOutput('A0B0C0');
 
     await act(async () => {
@@ -104,7 +112,7 @@ describe('ReactInterleavedUpdates', () => {
       startTransition(() => {
         setStep(1);
       });
-      expect(Scheduler).toFlushAndYieldThrough(['A1', 'B1']);
+      await waitFor(['A1', 'B1']);
 
       // Schedule an interleaved update. This gets placed on a special queue.
       startTransition(() => {
@@ -112,7 +120,7 @@ describe('ReactInterleavedUpdates', () => {
       });
 
       // Finish rendering the first update.
-      expect(Scheduler).toFlushUntilNextPaint(['C1']);
+      await waitForPaint(['C1']);
 
       // Schedule another update. (In the regression case, this was treated
       // as a normal, non-interleaved update and it was inserted into the queue
@@ -122,7 +130,7 @@ describe('ReactInterleavedUpdates', () => {
       });
     });
     // The last update should win.
-    expect(Scheduler).toHaveYielded(['A3', 'B3', 'C3']);
+    assertLog(['A3', 'B3', 'C3']);
     expect(root).toMatchRenderedOutput('A3B3C3');
   });
 });
diff --git a/packages/react/src/__tests__/ReactProfiler-test.internal.js b/packages/react/src/__tests__/ReactProfiler-test.internal.js
index bd7f13afac8d9..5635f2d61bf31 100644
--- a/packages/react/src/__tests__/ReactProfiler-test.internal.js
+++ b/packages/react/src/__tests__/ReactProfiler-test.internal.js
@@ -1874,7 +1874,7 @@ describe(`onPostCommit`, () => {
     loadModules();
   });
 
-  it('should report time spent in passive effects', () => {
+  it('should report time spent in passive effects', async () => {
     const callback = jest.fn();
 
     const ComponentWithEffects = () => {
@@ -1910,7 +1910,7 @@ describe(`onPostCommit`, () => {
         </React.Profiler>,
       );
     });
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -1931,7 +1931,7 @@ describe(`onPostCommit`, () => {
         </React.Profiler>,
       );
     });
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -1950,7 +1950,7 @@ describe(`onPostCommit`, () => {
         <React.Profiler id="unmount-test" onPostCommit={callback} />,
       );
     });
-    Scheduler.unstable_flushAll();
+    await waitForAll([]);
 
     expect(callback).toHaveBeenCalledTimes(3);