From 147bdef11bbeb8f4aef18c56d53ec1591fce8653 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Markb=C3=A5ge?= <sema@fb.com>
Date: Wed, 8 Apr 2020 20:54:54 -0700
Subject: [PATCH] Port more tests to the Scheduler.unstable_yieldValue pattern
 and drop internal.js (#18549)

* Drop the .internal.js suffix on some files that don't need it anymore

* Port some ops patterns to scheduler yield

* Fix triangle test to avoid side-effects in constructor

* Move replaying of setState updaters until after the effect

Otherwise any warnings get silenced if they're deduped.

* Drop .internal.js in more files

* Don't check propTypes on a simple memo component unless it's lazy

Comparing the elementType doesn't work for this because it will never be
the same for a simple element.

This caused us to double validate these. This was covered up because in
internal tests this was deduped since they shared the prop types cache
but since we now inline it, it doesn't get deduped.
---
 ...internal.js => createSubscription-test.js} |   0
 ...internal.js => ReactDOMFiberAsync-test.js} |   0
 ....internal.js => ChangeEventPlugin-test.js} |  76 +-
 ....internal.js => SimpleEventPlugin-test.js} |  35 +-
 .../src/dom/__tests__/Input-test.internal.js  |  47 +-
 .../MixedResponders-test-internal.js          |  28 +-
 .../src/ReactFiberBeginWork.js                |  20 +-
 .../react-reconciler/src/ReactUpdateQueue.js  |  12 +-
 ...st.internal.js => ReactExpiration-test.js} |   0
 ...t.internal.js => ReactIncremental-test.js} | 724 ++++++++----------
 ...tIncrementalErrorHandling-test.internal.js | 146 ++--
 ....js => ReactIncrementalReflection-test.js} |   0
 ....js => ReactIncrementalScheduling-test.js} |  24 +-
 ...js => ReactIncrementalSideEffects-test.js} |   0
 ...al.js => ReactIncrementalTriangle-test.js} |  18 +-
 ...nal.js => ReactIncrementalUpdates-test.js} |  77 +-
 ...emo-test.internal.js => ReactMemo-test.js} |   0
 ...st.internal.js => ReactNewContext-test.js} |   2 +-
 ...l.js => ReactSchedulerIntegration-test.js} |   0
 ...rnal.js => ReactTestRendererAsync-test.js} |   0
 ...st.internal.js => useSubscription-test.js} |   0
 21 files changed, 494 insertions(+), 715 deletions(-)
 rename packages/create-subscription/src/__tests__/{createSubscription-test.internal.js => createSubscription-test.js} (100%)
 rename packages/react-dom/src/__tests__/{ReactDOMFiberAsync-test.internal.js => ReactDOMFiberAsync-test.js} (100%)
 rename packages/react-dom/src/events/__tests__/{ChangeEventPlugin-test.internal.js => ChangeEventPlugin-test.js} (93%)
 rename packages/react-dom/src/events/__tests__/{SimpleEventPlugin-test.internal.js => SimpleEventPlugin-test.js} (95%)
 rename packages/react-reconciler/src/__tests__/{ReactExpiration-test.internal.js => ReactExpiration-test.js} (100%)
 rename packages/react-reconciler/src/__tests__/{ReactIncremental-test.internal.js => ReactIncremental-test.js} (83%)
 rename packages/react-reconciler/src/__tests__/{ReactIncrementalReflection-test.internal.js => ReactIncrementalReflection-test.js} (100%)
 rename packages/react-reconciler/src/__tests__/{ReactIncrementalScheduling-test.internal.js => ReactIncrementalScheduling-test.js} (96%)
 rename packages/react-reconciler/src/__tests__/{ReactIncrementalSideEffects-test.internal.js => ReactIncrementalSideEffects-test.js} (100%)
 rename packages/react-reconciler/src/__tests__/{ReactIncrementalTriangle-test.internal.js => ReactIncrementalTriangle-test.js} (98%)
 rename packages/react-reconciler/src/__tests__/{ReactIncrementalUpdates-test.internal.js => ReactIncrementalUpdates-test.js} (94%)
 rename packages/react-reconciler/src/__tests__/{ReactMemo-test.internal.js => ReactMemo-test.js} (100%)
 rename packages/react-reconciler/src/__tests__/{ReactNewContext-test.internal.js => ReactNewContext-test.js} (99%)
 rename packages/react-reconciler/src/__tests__/{ReactSchedulerIntegration-test.internal.js => ReactSchedulerIntegration-test.js} (100%)
 rename packages/react-test-renderer/src/__tests__/{ReactTestRendererAsync-test.internal.js => ReactTestRendererAsync-test.js} (100%)
 rename packages/use-subscription/src/__tests__/{useSubscription-test.internal.js => useSubscription-test.js} (100%)

diff --git a/packages/create-subscription/src/__tests__/createSubscription-test.internal.js b/packages/create-subscription/src/__tests__/createSubscription-test.js
similarity index 100%
rename from packages/create-subscription/src/__tests__/createSubscription-test.internal.js
rename to packages/create-subscription/src/__tests__/createSubscription-test.js
diff --git a/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js
similarity index 100%
rename from packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js
rename to packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js
diff --git a/packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.internal.js b/packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.js
similarity index 93%
rename from packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.internal.js
rename to packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.js
index 8357dbc633..8be8e5f18f 100644
--- a/packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/ChangeEventPlugin-test.js
@@ -470,7 +470,7 @@ describe('ChangeEventPlugin', () => {
     beforeEach(() => {
       jest.resetModules();
       ReactFeatureFlags = require('shared/ReactFeatureFlags');
-      ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
       React = require('react');
       ReactDOM = require('react-dom');
       TestUtils = require('react-dom/test-utils');
@@ -481,13 +481,11 @@ describe('ChangeEventPlugin', () => {
       const root = ReactDOM.createRoot(container);
       let input;
 
-      let ops = [];
-
       class ControlledInput extends React.Component {
         state = {value: 'initial'};
         onChange = event => this.setState({value: event.target.value});
         render() {
-          ops.push(`render: ${this.state.value}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
           const controlledValue =
             this.state.value === 'changed' ? 'changed [!]' : this.state.value;
           return (
@@ -504,22 +502,19 @@ describe('ChangeEventPlugin', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledInput />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: initial']);
+      expect(Scheduler).toFlushAndYield(['render: initial']);
       expect(input.value).toBe('initial');
 
-      ops = [];
-
       // Trigger a change event.
       setUntrackedValue.call(input, 'changed');
       input.dispatchEvent(
         new Event('input', {bubbles: true, cancelable: true}),
       );
       // Change should synchronously flush
-      expect(ops).toEqual(['render: changed']);
+      expect(Scheduler).toHaveYielded(['render: changed']);
       // Value should be the controlled value, not the original one
       expect(input.value).toBe('changed [!]');
     });
@@ -528,15 +523,13 @@ describe('ChangeEventPlugin', () => {
       const root = ReactDOM.createRoot(container);
       let input;
 
-      let ops = [];
-
       class ControlledInput extends React.Component {
         state = {checked: false};
         onChange = event => {
           this.setState({checked: event.target.checked});
         };
         render() {
-          ops.push(`render: ${this.state.checked}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.checked}`);
           const controlledValue = this.props.reverse
             ? !this.state.checked
             : this.state.checked;
@@ -554,35 +547,30 @@ describe('ChangeEventPlugin', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledInput reverse={false} />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: false']);
+      expect(Scheduler).toFlushAndYield(['render: false']);
       expect(input.checked).toBe(false);
 
-      ops = [];
-
       // Trigger a change event.
       input.dispatchEvent(
         new MouseEvent('click', {bubbles: true, cancelable: true}),
       );
       // Change should synchronously flush
-      expect(ops).toEqual(['render: true']);
+      expect(Scheduler).toHaveYielded(['render: true']);
       expect(input.checked).toBe(true);
 
       // Now let's make sure we're using the controlled value.
       root.render(<ControlledInput reverse={true} />);
-      Scheduler.unstable_flushAll();
-
-      ops = [];
+      expect(Scheduler).toFlushAndYield(['render: true']);
 
       // Trigger another change event.
       input.dispatchEvent(
         new MouseEvent('click', {bubbles: true, cancelable: true}),
       );
       // Change should synchronously flush
-      expect(ops).toEqual(['render: true']);
+      expect(Scheduler).toHaveYielded(['render: true']);
       expect(input.checked).toBe(false);
     });
 
@@ -590,13 +578,11 @@ describe('ChangeEventPlugin', () => {
       const root = ReactDOM.createRoot(container);
       let textarea;
 
-      let ops = [];
-
       class ControlledTextarea extends React.Component {
         state = {value: 'initial'};
         onChange = event => this.setState({value: event.target.value});
         render() {
-          ops.push(`render: ${this.state.value}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
           const controlledValue =
             this.state.value === 'changed' ? 'changed [!]' : this.state.value;
           return (
@@ -613,22 +599,19 @@ describe('ChangeEventPlugin', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledTextarea />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(textarea).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: initial']);
+      expect(Scheduler).toFlushAndYield(['render: initial']);
       expect(textarea.value).toBe('initial');
 
-      ops = [];
-
       // Trigger a change event.
       setUntrackedTextareaValue.call(textarea, 'changed');
       textarea.dispatchEvent(
         new Event('input', {bubbles: true, cancelable: true}),
       );
       // Change should synchronously flush
-      expect(ops).toEqual(['render: changed']);
+      expect(Scheduler).toHaveYielded(['render: changed']);
       // Value should be the controlled value, not the original one
       expect(textarea.value).toBe('changed [!]');
     });
@@ -637,13 +620,11 @@ describe('ChangeEventPlugin', () => {
       const root = ReactDOM.createRoot(container);
       let input;
 
-      let ops = [];
-
       class ControlledInput extends React.Component {
         state = {value: 'initial'};
         onChange = event => this.setState({value: event.target.value});
         render() {
-          ops.push(`render: ${this.state.value}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
           const controlledValue =
             this.state.value === 'changed' ? 'changed [!]' : this.state.value;
           return (
@@ -664,22 +645,19 @@ describe('ChangeEventPlugin', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledInput />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: initial']);
+      expect(Scheduler).toFlushAndYield(['render: initial']);
       expect(input.value).toBe('initial');
 
-      ops = [];
-
       // Trigger a change event.
       setUntrackedValue.call(input, 'changed');
       input.dispatchEvent(
         new Event('input', {bubbles: true, cancelable: true}),
       );
       // Change should synchronously flush
-      expect(ops).toEqual(['render: changed']);
+      expect(Scheduler).toHaveYielded(['render: changed']);
       // Value should be the controlled value, not the original one
       expect(input.value).toBe('changed [!]');
     });
@@ -688,8 +666,6 @@ describe('ChangeEventPlugin', () => {
       const root = ReactDOM.createRoot(container);
       let input;
 
-      let ops = [];
-
       class ControlledInput extends React.Component {
         state = {value: 'initial'};
         onChange = event => this.setState({value: event.target.value});
@@ -697,7 +673,7 @@ describe('ChangeEventPlugin', () => {
           this.setState({value: ''});
         };
         render() {
-          ops.push(`render: ${this.state.value}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
           const controlledValue =
             this.state.value === 'changed' ? 'changed [!]' : this.state.value;
           return (
@@ -715,27 +691,23 @@ describe('ChangeEventPlugin', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledInput />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: initial']);
+      expect(Scheduler).toFlushAndYield(['render: initial']);
       expect(input.value).toBe('initial');
 
-      ops = [];
-
       // Trigger a click event
       input.dispatchEvent(
         new Event('click', {bubbles: true, cancelable: true}),
       );
       // Nothing should have changed
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input.value).toBe('initial');
 
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
       // Now the click update has flushed.
-      expect(ops).toEqual(['render: ']);
+      expect(Scheduler).toFlushAndYield(['render: ']);
       expect(input.value).toBe('');
     });
 
diff --git a/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js b/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.js
similarity index 95%
rename from packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
rename to packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.js
index 0dd4952a3c..03502cdb5a 100644
--- a/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.js
@@ -12,7 +12,6 @@
 describe('SimpleEventPlugin', function() {
   let React;
   let ReactDOM;
-  let ReactFeatureFlags;
   let Scheduler;
 
   let onClick;
@@ -184,7 +183,6 @@ describe('SimpleEventPlugin', function() {
     container = document.createElement('div');
     document.body.appendChild(container);
 
-    const ops = [];
     let button;
     class Button extends React.Component {
       state = {count: 0};
@@ -193,7 +191,7 @@ describe('SimpleEventPlugin', function() {
           count: state.count + 1,
         }));
       componentDidUpdate() {
-        ops.push(`didUpdate - Count: ${this.state.count}`);
+        Scheduler.unstable_yieldValue(`didUpdate - Count: ${this.state.count}`);
       }
       render() {
         return (
@@ -221,20 +219,19 @@ describe('SimpleEventPlugin', function() {
 
     ReactDOM.render(<Button />, container);
     expect(button.textContent).toEqual('Count: 0');
-    expect(ops).toEqual([]);
+    expect(Scheduler).toHaveYielded([]);
 
     click();
 
     // There should be exactly one update.
-    expect(ops).toEqual(['didUpdate - Count: 3']);
+    expect(Scheduler).toHaveYielded(['didUpdate - Count: 3']);
     expect(button.textContent).toEqual('Count: 3');
   });
 
   describe('interactive events, in concurrent mode', () => {
     beforeEach(() => {
       jest.resetModules();
-      ReactFeatureFlags = require('shared/ReactFeatureFlags');
-      ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
       ReactDOM = require('react-dom');
       Scheduler = require('scheduler');
     });
@@ -246,19 +243,17 @@ describe('SimpleEventPlugin', function() {
         const root = ReactDOM.createRoot(container);
         document.body.appendChild(container);
 
-        let ops = [];
-
         let button;
         class Button extends React.Component {
           state = {disabled: false};
           onClick = () => {
             // Perform some side-effect
-            ops.push('Side-effect');
+            Scheduler.unstable_yieldValue('Side-effect');
             // Disable the button
             this.setState({disabled: true});
           };
           render() {
-            ops.push(
+            Scheduler.unstable_yieldValue(
               `render button: ${this.state.disabled ? 'disabled' : 'enabled'}`,
             );
             return (
@@ -274,13 +269,10 @@ describe('SimpleEventPlugin', function() {
         // Initial mount
         root.render(<Button />);
         // Should not have flushed yet because it's async
-        expect(ops).toEqual([]);
+        expect(Scheduler).toHaveYielded([]);
         expect(button).toBe(undefined);
         // Flush async work
-        Scheduler.unstable_flushAll();
-        expect(ops).toEqual(['render button: enabled']);
-
-        ops = [];
+        expect(Scheduler).toFlushAndYield(['render button: enabled']);
 
         function click() {
           button.dispatchEvent(
@@ -290,17 +282,15 @@ describe('SimpleEventPlugin', function() {
 
         // Click the button to trigger the side-effect
         click();
-        expect(ops).toEqual([
+        expect(Scheduler).toHaveYielded([
           // The handler fired
           'Side-effect',
           // but the component did not re-render yet, because it's async
         ]);
 
-        ops = [];
-
         // Click the button again
         click();
-        expect(ops).toEqual([
+        expect(Scheduler).toHaveYielded([
           // Before handling this second click event, the previous interactive
           // update is flushed
           'render button: disabled',
@@ -308,8 +298,6 @@ describe('SimpleEventPlugin', function() {
           // side-effect
         ]);
 
-        ops = [];
-
         // The handler should not fire again no matter how many times we
         // click the handler.
         click();
@@ -317,8 +305,7 @@ describe('SimpleEventPlugin', function() {
         click();
         click();
         click();
-        Scheduler.unstable_flushAll();
-        expect(ops).toEqual([]);
+        expect(Scheduler).toFlushAndYield([]);
       },
     );
 
diff --git a/packages/react-interactions/events/src/dom/__tests__/Input-test.internal.js b/packages/react-interactions/events/src/dom/__tests__/Input-test.internal.js
index f01787b2d0..8d844af26e 100644
--- a/packages/react-interactions/events/src/dom/__tests__/Input-test.internal.js
+++ b/packages/react-interactions/events/src/dom/__tests__/Input-test.internal.js
@@ -34,7 +34,7 @@ const setUntrackedTextareaValue = Object.getOwnPropertyDescriptor(
 const modulesInit = () => {
   ReactFeatureFlags = require('shared/ReactFeatureFlags');
   ReactFeatureFlags.enableDeprecatedFlareAPI = true;
-  ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
   React = require('react');
   ReactDOM = require('react-dom');
   Scheduler = require('scheduler');
@@ -797,8 +797,6 @@ describe('Input event responder', () => {
         const root = ReactDOM.createRoot(container);
         let input;
 
-        let ops = [];
-
         function Component({innerRef, onChange, controlledValue}) {
           const listener = useInput({
             onChange,
@@ -817,7 +815,7 @@ describe('Input event responder', () => {
           state = {value: 'initial'};
           onChange = event => this.setState({value: event.target.value});
           render() {
-            ops.push(`render: ${this.state.value}`);
+            Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
             const controlledValue =
               this.state.value === 'changed' ? 'changed [!]' : this.state.value;
             return (
@@ -833,22 +831,19 @@ describe('Input event responder', () => {
         // Initial mount. Test that this is async.
         root.render(<ControlledInput />);
         // Should not have flushed yet.
-        expect(ops).toEqual([]);
+        expect(Scheduler).toHaveYielded([]);
         expect(input).toBe(undefined);
         // Flush callbacks.
-        Scheduler.unstable_flushAll();
-        expect(ops).toEqual(['render: initial']);
+        expect(Scheduler).toFlushAndYield(['render: initial']);
         expect(input.value).toBe('initial');
 
-        ops = [];
-
         // Trigger a change event.
         setUntrackedValue.call(input, 'changed');
         input.dispatchEvent(
           new Event('input', {bubbles: true, cancelable: true}),
         );
         // Change should synchronously flush
-        expect(ops).toEqual(['render: changed']);
+        expect(Scheduler).toHaveYielded(['render: changed']);
         // Value should be the controlled value, not the original one
         expect(input.value).toBe('changed [!]');
       });
@@ -857,8 +852,6 @@ describe('Input event responder', () => {
         const root = ReactDOM.createRoot(container);
         let input;
 
-        let ops = [];
-
         function Component({innerRef, onChange, controlledValue}) {
           const listener = useInput({
             onChange,
@@ -879,7 +872,7 @@ describe('Input event responder', () => {
             this.setState({checked: event.target.checked});
           };
           render() {
-            ops.push(`render: ${this.state.checked}`);
+            Scheduler.unstable_yieldValue(`render: ${this.state.checked}`);
             const controlledValue = this.props.reverse
               ? !this.state.checked
               : this.state.checked;
@@ -896,35 +889,30 @@ describe('Input event responder', () => {
         // Initial mount. Test that this is async.
         root.render(<ControlledInput reverse={false} />);
         // Should not have flushed yet.
-        expect(ops).toEqual([]);
+        expect(Scheduler).toHaveYielded([]);
         expect(input).toBe(undefined);
         // Flush callbacks.
-        Scheduler.unstable_flushAll();
-        expect(ops).toEqual(['render: false']);
+        expect(Scheduler).toFlushAndYield(['render: false']);
         expect(input.checked).toBe(false);
 
-        ops = [];
-
         // Trigger a change event.
         input.dispatchEvent(
           new MouseEvent('click', {bubbles: true, cancelable: true}),
         );
         // Change should synchronously flush
-        expect(ops).toEqual(['render: true']);
+        expect(Scheduler).toHaveYielded(['render: true']);
         expect(input.checked).toBe(true);
 
         // Now let's make sure we're using the controlled value.
         root.render(<ControlledInput reverse={true} />);
-        Scheduler.unstable_flushAll();
-
-        ops = [];
+        expect(Scheduler).toFlushAndYield(['render: true']);
 
         // Trigger another change event.
         input.dispatchEvent(
           new MouseEvent('click', {bubbles: true, cancelable: true}),
         );
         // Change should synchronously flush
-        expect(ops).toEqual(['render: true']);
+        expect(Scheduler).toHaveYielded(['render: true']);
         expect(input.checked).toBe(false);
       });
 
@@ -932,8 +920,6 @@ describe('Input event responder', () => {
         const root = ReactDOM.createRoot(container);
         let textarea;
 
-        let ops = [];
-
         function Component({innerRef, onChange, controlledValue}) {
           const listener = useInput({
             onChange,
@@ -952,7 +938,7 @@ describe('Input event responder', () => {
           state = {value: 'initial'};
           onChange = event => this.setState({value: event.target.value});
           render() {
-            ops.push(`render: ${this.state.value}`);
+            Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
             const controlledValue =
               this.state.value === 'changed' ? 'changed [!]' : this.state.value;
             return (
@@ -968,22 +954,19 @@ describe('Input event responder', () => {
         // Initial mount. Test that this is async.
         root.render(<ControlledTextarea />);
         // Should not have flushed yet.
-        expect(ops).toEqual([]);
+        expect(Scheduler).toHaveYielded([]);
         expect(textarea).toBe(undefined);
         // Flush callbacks.
-        Scheduler.unstable_flushAll();
-        expect(ops).toEqual(['render: initial']);
+        expect(Scheduler).toFlushAndYield(['render: initial']);
         expect(textarea.value).toBe('initial');
 
-        ops = [];
-
         // Trigger a change event.
         setUntrackedTextareaValue.call(textarea, 'changed');
         textarea.dispatchEvent(
           new Event('input', {bubbles: true, cancelable: true}),
         );
         // Change should synchronously flush
-        expect(ops).toEqual(['render: changed']);
+        expect(Scheduler).toHaveYielded(['render: changed']);
         // Value should be the controlled value, not the original one
         expect(textarea.value).toBe('changed [!]');
       });
diff --git a/packages/react-interactions/events/src/dom/__tests__/MixedResponders-test-internal.js b/packages/react-interactions/events/src/dom/__tests__/MixedResponders-test-internal.js
index 6dc3ee24ec..2a062a40fb 100644
--- a/packages/react-interactions/events/src/dom/__tests__/MixedResponders-test-internal.js
+++ b/packages/react-interactions/events/src/dom/__tests__/MixedResponders-test-internal.js
@@ -191,8 +191,6 @@ describe('mixing responders with the heritage event system', () => {
 
       const button = React.createRef();
 
-      const ops = [];
-
       function MyComponent() {
         const [pressesCount, updatePressesCount] = useState(0);
         const [clicksCount, updateClicksCount] = useState(0);
@@ -204,7 +202,7 @@ describe('mixing responders with the heritage event system', () => {
           const target = createEventTarget(button.current);
           target.click();
           // Text context should not have changed
-          ops.push(newContainer.textContent);
+          Scheduler.unstable_yieldValue(newContainer.textContent);
           updatePressesCount(pressesCount + 1);
         }
 
@@ -229,30 +227,26 @@ describe('mixing responders with the heritage event system', () => {
       const root = ReactDOM.createRoot(newContainer);
 
       root.render(<MyComponent />);
-      Scheduler.unstable_flushAll();
+      expect(Scheduler).toFlushWithoutYielding();
       expect(newContainer.textContent).toEqual('Presses: 0, Clicks: 0');
 
       const target = createEventTarget(button.current);
       target.pointerdown({timeStamp: 100});
       target.pointerup({timeStamp: 100});
 
-      Scheduler.unstable_flushAll();
+      expect(Scheduler).toHaveYielded(['Presses: 0, Clicks: 0']);
+      expect(Scheduler).toFlushWithoutYielding();
       expect(newContainer.textContent).toEqual('Presses: 1, Clicks: 1');
-
-      expect(ops).toEqual(['Presses: 0, Clicks: 0']);
     },
   );
 
   describe('mixing the Input and Press repsonders', () => {
     it('is async for non-input events', () => {
-      ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
       const useTap = require('react-interactions/events/tap').useTap;
       const useInput = require('react-interactions/events/input').useInput;
       const root = ReactDOM.createRoot(container);
       let input;
 
-      let ops = [];
-
       function Component({innerRef, onChange, controlledValue, listeners}) {
         const inputListener = useInput({onChange});
         return (
@@ -286,7 +280,7 @@ describe('mixing responders with the heritage event system', () => {
           this.setState({value: ''});
         };
         render() {
-          ops.push(`render: ${this.state.value}`);
+          Scheduler.unstable_yieldValue(`render: ${this.state.value}`);
           const controlledValue =
             this.state.value === 'changed' ? 'changed [!]' : this.state.value;
           return (
@@ -303,15 +297,12 @@ describe('mixing responders with the heritage event system', () => {
       // Initial mount. Test that this is async.
       root.render(<ControlledInput />);
       // Should not have flushed yet.
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input).toBe(undefined);
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
-      expect(ops).toEqual(['render: initial']);
+      expect(Scheduler).toFlushAndYield(['render: initial']);
       expect(input.value).toBe('initial');
 
-      ops = [];
-
       // Trigger a click event
       input.dispatchEvent(
         new MouseEvent('mousedown', {
@@ -328,13 +319,12 @@ describe('mixing responders with the heritage event system', () => {
         }),
       );
       // Nothing should have changed
-      expect(ops).toEqual([]);
+      expect(Scheduler).toHaveYielded([]);
       expect(input.value).toBe('initial');
 
       // Flush callbacks.
-      Scheduler.unstable_flushAll();
       // Now the click update has flushed.
-      expect(ops).toEqual(['render: ']);
+      expect(Scheduler).toFlushAndYield(['render: ']);
       expect(input.value).toBe('');
     });
   });
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js
index 2af5d28fcf..73dde5757e 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.js
@@ -499,17 +499,17 @@ function updateSimpleMemoComponent(
         } catch (x) {
           outerMemoType = null;
         }
+        // Inner propTypes will be validated in the function component path.
+        const outerPropTypes = outerMemoType && (outerMemoType: any).propTypes;
+        if (outerPropTypes) {
+          checkPropTypes(
+            outerPropTypes,
+            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
+            'prop',
+            getComponentName(outerMemoType),
+          );
+        }
       }
-      const outerPropTypes = outerMemoType && (outerMemoType: any).propTypes;
-      if (outerPropTypes) {
-        checkPropTypes(
-          outerPropTypes,
-          nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
-          'prop',
-          getComponentName(outerMemoType),
-        );
-      }
-      // Inner propTypes will be validated in the function component path.
     }
   }
   if (current !== null) {
diff --git a/packages/react-reconciler/src/ReactUpdateQueue.js b/packages/react-reconciler/src/ReactUpdateQueue.js
index ec29c42520..4cf5954c12 100644
--- a/packages/react-reconciler/src/ReactUpdateQueue.js
+++ b/packages/react-reconciler/src/ReactUpdateQueue.js
@@ -334,6 +334,9 @@ function getStateFromUpdate<State>(
         // Updater function
         if (__DEV__) {
           enterDisallowedContextReadInDEV();
+        }
+        const nextState = payload.call(instance, prevState, nextProps);
+        if (__DEV__) {
           if (
             debugRenderPhaseSideEffectsForStrictMode &&
             workInProgress.mode & StrictMode
@@ -345,9 +348,6 @@ function getStateFromUpdate<State>(
               reenableLogs();
             }
           }
-        }
-        const nextState = payload.call(instance, prevState, nextProps);
-        if (__DEV__) {
           exitDisallowedContextReadInDEV();
         }
         return nextState;
@@ -367,6 +367,9 @@ function getStateFromUpdate<State>(
         // Updater function
         if (__DEV__) {
           enterDisallowedContextReadInDEV();
+        }
+        partialState = payload.call(instance, prevState, nextProps);
+        if (__DEV__) {
           if (
             debugRenderPhaseSideEffectsForStrictMode &&
             workInProgress.mode & StrictMode
@@ -378,9 +381,6 @@ function getStateFromUpdate<State>(
               reenableLogs();
             }
           }
-        }
-        partialState = payload.call(instance, prevState, nextProps);
-        if (__DEV__) {
           exitDisallowedContextReadInDEV();
         }
       } else {
diff --git a/packages/react-reconciler/src/__tests__/ReactExpiration-test.internal.js b/packages/react-reconciler/src/__tests__/ReactExpiration-test.js
similarity index 100%
rename from packages/react-reconciler/src/__tests__/ReactExpiration-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactExpiration-test.js
diff --git a/packages/react-reconciler/src/__tests__/ReactIncremental-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
similarity index 83%
rename from packages/react-reconciler/src/__tests__/ReactIncremental-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncremental-test.js
index b51352f1c1..e71caeb1ce 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncremental-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncremental-test.js
@@ -11,7 +11,6 @@
 'use strict';
 
 let React;
-let ReactFeatureFlags;
 let ReactNoop;
 let Scheduler;
 let PropTypes;
@@ -19,8 +18,6 @@ let PropTypes;
 describe('ReactIncremental', () => {
   beforeEach(() => {
     jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
@@ -64,20 +61,18 @@ describe('ReactIncremental', () => {
   });
 
   it('updates a previous render', () => {
-    let ops = [];
-
     function Header() {
-      ops.push('Header');
+      Scheduler.unstable_yieldValue('Header');
       return <h1>Hi</h1>;
     }
 
     function Content(props) {
-      ops.push('Content');
+      Scheduler.unstable_yieldValue('Content');
       return <div>{props.children}</div>;
     }
 
     function Footer() {
-      ops.push('Footer');
+      Scheduler.unstable_yieldValue('Footer');
       return <footer>Bye</footer>;
     }
 
@@ -85,7 +80,7 @@ describe('ReactIncremental', () => {
     const footer = <Footer />;
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           {header}
@@ -96,11 +91,9 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo text="foo" />, () =>
-      ops.push('renderCallbackCalled'),
+      Scheduler.unstable_yieldValue('renderCallbackCalled'),
     );
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'Foo',
       'Header',
       'Content',
@@ -108,21 +101,17 @@ describe('ReactIncremental', () => {
       'renderCallbackCalled',
     ]);
 
-    ops = [];
-
     ReactNoop.render(<Foo text="bar" />, () =>
-      ops.push('firstRenderCallbackCalled'),
+      Scheduler.unstable_yieldValue('firstRenderCallbackCalled'),
     );
     ReactNoop.render(<Foo text="bar" />, () =>
-      ops.push('secondRenderCallbackCalled'),
+      Scheduler.unstable_yieldValue('secondRenderCallbackCalled'),
     );
-    expect(Scheduler).toFlushWithoutYielding();
-
     // TODO: Test bail out of host components. This is currently unobservable.
 
     // Since this is an update, it should bail out and reuse the work from
     // Header and Content.
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'Foo',
       'Content',
       'firstRenderCallbackCalled',
@@ -267,20 +256,18 @@ describe('ReactIncremental', () => {
   });
 
   it('can deprioritize a tree from without dropping work', () => {
-    let ops = [];
-
     function Bar(props) {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
     }
 
     function Middle(props) {
-      ops.push('Middle');
+      Scheduler.unstable_yieldValue('Middle');
       return <span>{props.children}</span>;
     }
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           <Bar>{props.text}</Bar>
@@ -299,42 +286,35 @@ describe('ReactIncremental', () => {
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Foo text="foo" />);
     });
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo', 'Bar', 'Bar', 'Middle', 'Middle']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Bar']);
+    expect(Scheduler).toFlushAndYield(['Middle', 'Middle']);
 
     // Render the high priority work (everything except the hidden trees).
     ReactNoop.flushSync(() => {
       ReactNoop.render(<Foo text="foo" />);
     });
-    expect(ops).toEqual(['Foo', 'Bar', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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).toFlushWithoutYielding();
-    expect(ops).toEqual(['Middle', 'Middle']);
+    expect(Scheduler).toFlushAndYield(['Middle', 'Middle']);
   });
 
   xit('can resume work in a subtree even when a parent bails out', () => {
-    let ops = [];
-
     function Bar(props) {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
     }
 
     function Tester() {
       // This component is just here to ensure that the bail out is
       // in fact in effect in the expected place for this test.
-      ops.push('Tester');
+      Scheduler.unstable_yieldValue('Tester');
       return <div />;
     }
 
     function Middle(props) {
-      ops.push('Middle');
+      Scheduler.unstable_yieldValue('Middle');
       return <span>{props.children}</span>;
     }
 
@@ -350,7 +330,7 @@ describe('ReactIncremental', () => {
     );
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           <Bar>{props.text}</Bar>
@@ -364,28 +344,21 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo text="foo" />);
     ReactNoop.flushDeferredPri(52);
 
-    expect(ops).toEqual(['Foo', 'Bar', 'Tester', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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(ops).toEqual(['Foo', 'Bar', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Bar']);
 
     // Flush the rest to make sure that the bailout didn't block this work.
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Middle']);
+    expect(Scheduler).toFlushAndYield(['Middle']);
   });
 
   xit('can resume work in a bailed subtree within one pass', () => {
-    let ops = [];
-
     function Bar(props) {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
     }
 
@@ -396,13 +369,13 @@ describe('ReactIncremental', () => {
       render() {
         // This component is just here to ensure that the bail out is
         // in fact in effect in the expected place for this test.
-        ops.push('Tester');
+        Scheduler.unstable_yieldValue('Tester');
         return <div />;
       }
     }
 
     function Middle(props) {
-      ops.push('Middle');
+      Scheduler.unstable_yieldValue('Middle');
       return <span>{props.children}</span>;
     }
 
@@ -425,7 +398,7 @@ describe('ReactIncremental', () => {
     }
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div hidden={props.text === 'bar'}>
           <Bar>{props.text}</Bar>
@@ -439,48 +412,37 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<Foo text="foo" />);
     ReactNoop.flushDeferredPri(52 + 5);
 
-    expect(ops).toEqual(['Foo', 'Bar', 'Tester', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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(ops).toEqual(['Foo']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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).toFlushWithoutYielding();
-    expect(ops).toEqual(['Bar', 'Middle', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toFlushAndYield(['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(ops).toEqual(['Foo', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo', 'Bar', 'Bar']);
+    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Bar']);
   });
 
   xit('can resume mounting a class component', () => {
-    let ops = [];
     let foo;
     class Parent extends React.Component {
       shouldComponentUpdate() {
@@ -495,33 +457,30 @@ describe('ReactIncremental', () => {
       constructor(props) {
         super(props);
         // Test based on a www bug where props was null on resume
-        ops.push('Foo constructor: ' + props.prop);
+        Scheduler.unstable_yieldValue('Foo constructor: ' + props.prop);
       }
       render() {
         foo = this;
-        ops.push('Foo');
+        Scheduler.unstable_yieldValue('Foo');
         return <Bar />;
       }
     }
 
     function Bar() {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div />;
     }
 
     ReactNoop.render(<Parent prop="foo" />);
     ReactNoop.flushDeferredPri(20);
-    expect(ops).toEqual(['Foo constructor: foo', 'Foo']);
+    expect(Scheduler).toHaveYielded(['Foo constructor: foo', 'Foo']);
 
     foo.setState({value: 'bar'});
 
-    ops = [];
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo', 'Bar']);
+    expect(Scheduler).toFlushAndYield(['Foo', 'Bar']);
   });
 
   xit('reuses the same instance when resuming a class instance', () => {
-    let ops = [];
     let foo;
     class Parent extends React.Component {
       shouldComponentUpdate() {
@@ -537,39 +496,43 @@ describe('ReactIncremental', () => {
       constructor(props) {
         super(props);
         // Test based on a www bug where props was null on resume
-        ops.push('constructor: ' + props.prop);
+        Scheduler.unstable_yieldValue('constructor: ' + props.prop);
         constructorCount++;
       }
       UNSAFE_componentWillMount() {
-        ops.push('componentWillMount: ' + this.props.prop);
+        Scheduler.unstable_yieldValue('componentWillMount: ' + this.props.prop);
       }
       UNSAFE_componentWillReceiveProps() {
-        ops.push('componentWillReceiveProps: ' + this.props.prop);
+        Scheduler.unstable_yieldValue(
+          'componentWillReceiveProps: ' + this.props.prop,
+        );
       }
       componentDidMount() {
-        ops.push('componentDidMount: ' + this.props.prop);
+        Scheduler.unstable_yieldValue('componentDidMount: ' + this.props.prop);
       }
       UNSAFE_componentWillUpdate() {
-        ops.push('componentWillUpdate: ' + this.props.prop);
+        Scheduler.unstable_yieldValue(
+          'componentWillUpdate: ' + this.props.prop,
+        );
       }
       componentDidUpdate() {
-        ops.push('componentDidUpdate: ' + this.props.prop);
+        Scheduler.unstable_yieldValue('componentDidUpdate: ' + this.props.prop);
       }
       render() {
         foo = this;
-        ops.push('render: ' + this.props.prop);
+        Scheduler.unstable_yieldValue('render: ' + this.props.prop);
         return <Bar />;
       }
     }
 
     function Bar() {
-      ops.push('Foo did complete');
+      Scheduler.unstable_yieldValue('Foo did complete');
       return <div />;
     }
 
     ReactNoop.render(<Parent prop="foo" />);
     ReactNoop.flushDeferredPri(25);
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'constructor: foo',
       'componentWillMount: foo',
       'render: foo',
@@ -578,10 +541,9 @@ describe('ReactIncremental', () => {
 
     foo.setState({value: 'bar'});
 
-    ops = [];
     expect(Scheduler).toFlushWithoutYielding();
     expect(constructorCount).toEqual(1);
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'componentWillMount: foo',
       'render: foo',
       'Foo did complete',
@@ -590,15 +552,13 @@ describe('ReactIncremental', () => {
   });
 
   xit('can reuse work done after being preempted', () => {
-    let ops = [];
-
     function Bar(props) {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
     }
 
     function Middle(props) {
-      ops.push('Middle');
+      Scheduler.unstable_yieldValue('Middle');
       return <span>{props.children}</span>;
     }
 
@@ -619,7 +579,7 @@ describe('ReactIncremental', () => {
     );
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           <Bar>{props.text2}</Bar>
@@ -634,9 +594,7 @@ describe('ReactIncremental', () => {
 
     // We only finish the higher priority work. So the low pri content
     // has not yet finished mounting.
-    expect(ops).toEqual(['Foo', 'Bar', 'Middle', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar', 'Middle', 'Bar']);
 
     // Interrupt the rendering with a quick update. This should not touch the
     // middle content.
@@ -645,53 +603,43 @@ describe('ReactIncremental', () => {
 
     // 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(ops).toEqual(['Foo', 'Bar', 'Middle']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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(ops).toEqual(['Foo', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
 
     // The middle content is now pending rendering...
     ReactNoop.flushDeferredPri(30 + 5);
-    expect(ops).toEqual(['Middle', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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(ops).toEqual(['Foo', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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).toFlushWithoutYielding();
-    expect(ops).toEqual(['Middle']);
+    expect(Scheduler).toFlushAndYield(['Middle']);
   });
 
   xit('can reuse work that began but did not complete, after being preempted', () => {
-    let ops = [];
     let child;
     let sibling;
 
     function GreatGrandchild() {
-      ops.push('GreatGrandchild');
+      Scheduler.unstable_yieldValue('GreatGrandchild');
       return <div />;
     }
 
     function Grandchild() {
-      ops.push('Grandchild');
+      Scheduler.unstable_yieldValue('Grandchild');
       return <GreatGrandchild />;
     }
 
@@ -699,21 +647,21 @@ describe('ReactIncremental', () => {
       state = {step: 0};
       render() {
         child = this;
-        ops.push('Child');
+        Scheduler.unstable_yieldValue('Child');
         return <Grandchild />;
       }
     }
 
     class Sibling extends React.Component {
       render() {
-        ops.push('Sibling');
+        Scheduler.unstable_yieldValue('Sibling');
         sibling = this;
         return <div />;
       }
     }
 
     function Parent() {
-      ops.push('Parent');
+      Scheduler.unstable_yieldValue('Parent');
       return [
         // The extra div is necessary because when Parent bails out during the
         // high priority update, its progressedPriority is set to high.
@@ -730,27 +678,25 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Parent />);
     expect(Scheduler).toFlushWithoutYielding();
-    ops = [];
 
     // 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(ops).toEqual(['Child', 'Grandchild']);
+    expect(Scheduler).toHaveYielded(['Child', 'Grandchild']);
 
     // Interrupt the current low pri work with a high pri update elsewhere in
     // the tree.
-    ops = [];
+
     ReactNoop.flushSync(() => {
       sibling.setState({});
     });
-    expect(ops).toEqual(['Sibling']);
+    expect(Scheduler).toHaveYielded(['Sibling']);
 
     // Continue the low pri work. The work on Child and GrandChild was memoized
     // so they should not be worked on again.
-    ops = [];
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual([
+
+    expect(Scheduler).toFlushAndYield([
       // No Child
       // No Grandchild
       'GreatGrandchild',
@@ -758,10 +704,8 @@ describe('ReactIncremental', () => {
   });
 
   xit('can reuse work if shouldComponentUpdate is false, after being preempted', () => {
-    let ops = [];
-
     function Bar(props) {
-      ops.push('Bar');
+      Scheduler.unstable_yieldValue('Bar');
       return <div>{props.children}</div>;
     }
 
@@ -770,7 +714,7 @@ describe('ReactIncremental', () => {
         return this.props.children !== nextProps.children;
       }
       render() {
-        ops.push('Middle');
+        Scheduler.unstable_yieldValue('Middle');
         return <span>{this.props.children}</span>;
       }
     }
@@ -780,7 +724,7 @@ describe('ReactIncremental', () => {
         return this.props.step !== nextProps.step;
       }
       render() {
-        ops.push('Content');
+        Scheduler.unstable_yieldValue('Content');
         return (
           <div>
             <Middle>{this.props.step === 0 ? 'Hi' : 'Hello'}</Middle>
@@ -792,7 +736,7 @@ describe('ReactIncremental', () => {
     }
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           <Bar>{props.text}</Bar>
@@ -805,71 +749,62 @@ describe('ReactIncremental', () => {
 
     // Init
     ReactNoop.render(<Foo text="foo" step={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual(['Foo', 'Bar', 'Content', 'Middle', 'Bar', 'Middle']);
-
-    ops = [];
+    expect(Scheduler).toFlushAndYield([
+      '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(ops).toEqual(['Foo', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar']);
 
     // The middle content is now pending rendering...
     ReactNoop.flushDeferredPri(30 + 25 + 5);
-    expect(ops).toEqual(['Content', 'Middle', 'Bar']); // One more Middle left.
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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(ops).toEqual(['Foo', 'Bar']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['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).toFlushWithoutYielding();
-    expect(ops).toEqual(['Middle']);
+    expect(Scheduler).toFlushAndYield(['Middle']);
   });
 
   it('memoizes work even if shouldComponentUpdate returns false', () => {
-    let ops = [];
     class Foo extends React.Component {
       shouldComponentUpdate(nextProps) {
         // this.props is the memoized props. So this should return true for
         // every update except the first one.
         const shouldUpdate = this.props.step !== 1;
-        ops.push('shouldComponentUpdate: ' + shouldUpdate);
+        Scheduler.unstable_yieldValue('shouldComponentUpdate: ' + shouldUpdate);
         return shouldUpdate;
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         return <div />;
       }
     }
 
     ReactNoop.render(<Foo step={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield(['render']);
 
-    ops = [];
     ReactNoop.render(<Foo step={2} />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['shouldComponentUpdate: false']);
+    expect(Scheduler).toFlushAndYield(['shouldComponentUpdate: false']);
 
-    ops = [];
     ReactNoop.render(<Foo step={3} />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       // If the memoized props were not updated during last bail out, sCU will
       // keep returning false.
       'shouldComponentUpdate: true',
@@ -1041,10 +976,8 @@ describe('ReactIncremental', () => {
   });
 
   it('can forceUpdate', () => {
-    const ops = [];
-
     function Baz() {
-      ops.push('Baz');
+      Scheduler.unstable_yieldValue('Baz');
       return <div />;
     }
 
@@ -1058,13 +991,13 @@ describe('ReactIncremental', () => {
         return false;
       }
       render() {
-        ops.push('Bar');
+        Scheduler.unstable_yieldValue('Bar');
         return <Baz />;
       }
     }
 
     function Foo() {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return (
         <div>
           <Bar />
@@ -1073,11 +1006,9 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo', 'Bar', 'Baz']);
+    expect(Scheduler).toFlushAndYield(['Foo', 'Bar', 'Baz']);
     instance.forceUpdate();
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo', 'Bar', 'Baz', 'Bar', 'Baz']);
+    expect(Scheduler).toFlushAndYield(['Bar', 'Baz']);
   });
 
   it('should clear forceUpdate after update is flushed', () => {
@@ -1104,8 +1035,6 @@ describe('ReactIncremental', () => {
   });
 
   xit('can call sCU while resuming a partly mounted component', () => {
-    let ops = [];
-
     const instances = new Set();
 
     class Bar extends React.Component {
@@ -1118,13 +1047,13 @@ describe('ReactIncremental', () => {
         return this.props.x !== newProps.x || this.state.y !== newState.y;
       }
       render() {
-        ops.push('Bar:' + this.props.x);
+        Scheduler.unstable_yieldValue('Bar:' + this.props.x);
         return <span prop={'' + (this.props.x === this.state.y)} />;
       }
     }
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return [
         <Bar key="a" x="A" />,
         <Bar key="b" x={props.step === 0 ? 'B' : 'B2'} />,
@@ -1135,25 +1064,22 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Foo step={0} />);
     ReactNoop.flushDeferredPri(40);
-    expect(ops).toEqual(['Foo', 'Bar:A', 'Bar:B', 'Bar:C']);
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar:A', 'Bar:B', 'Bar:C']);
 
     expect(instances.size).toBe(3);
 
-    ops = [];
-
     ReactNoop.render(<Foo step={1} />);
     ReactNoop.flushDeferredPri(50);
     // 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(ops).toEqual(['Foo', 'Bar:B2', 'Bar:D']);
+    expect(Scheduler).toHaveYielded(['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', () => {
-    let ops = [];
     const instances = [];
 
     class Bar extends React.Component {
@@ -1168,7 +1094,9 @@ describe('ReactIncremental', () => {
         });
       }
       render() {
-        ops.push('Bar:' + this.props.x + '-' + this.props.step);
+        Scheduler.unstable_yieldValue(
+          'Bar:' + this.props.x + '-' + this.props.step,
+        );
         return <span prop={'' + (this.props.x === this.state.y)} />;
       }
     }
@@ -1176,12 +1104,12 @@ describe('ReactIncremental', () => {
     function Baz() {
       // This component is used as a sibling to Foo so that we can fully
       // complete Foo, without committing.
-      ops.push('Baz');
+      Scheduler.unstable_yieldValue('Baz');
       return <div />;
     }
 
     function Foo(props) {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return [
         <Bar key="a" x="A" step={props.step} />,
         <Bar key="b" x="B" step={props.step} />,
@@ -1197,8 +1125,6 @@ describe('ReactIncremental', () => {
     );
     expect(Scheduler).toFlushWithoutYielding();
 
-    ops = [];
-
     // Flush part way through with new props, fully completing the first Bar.
     // However, it doesn't commit yet.
     ReactNoop.render(
@@ -1209,33 +1135,32 @@ describe('ReactIncremental', () => {
       </div>,
     );
     ReactNoop.flushDeferredPri(45);
-    expect(ops).toEqual(['Foo', 'Bar:A-1', 'Bar:B-1', 'Baz']);
+    expect(Scheduler).toHaveYielded(['Foo', 'Bar:A-1', 'Bar:B-1', 'Baz']);
 
     // Make an update to the same Bar.
     instances[0].performAction();
 
-    ops = [];
-
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Bar:A-1', 'Baz']);
+    expect(Scheduler).toFlushAndYield(['Bar:A-1', 'Baz']);
   });
 
   xit('calls componentWillMount twice if the initial render is aborted', () => {
-    let ops = [];
-
     class LifeCycle extends React.Component {
       state = {x: this.props.x};
       UNSAFE_componentWillReceiveProps(nextProps) {
-        ops.push(
+        Scheduler.unstable_yieldValue(
           'componentWillReceiveProps:' + this.state.x + '-' + nextProps.x,
         );
         this.setState({x: nextProps.x});
       }
       UNSAFE_componentWillMount() {
-        ops.push('componentWillMount:' + this.state.x + '-' + this.props.x);
+        Scheduler.unstable_yieldValue(
+          'componentWillMount:' + this.state.x + '-' + this.props.x,
+        );
       }
       componentDidMount() {
-        ops.push('componentDidMount:' + this.state.x + '-' + this.props.x);
+        Scheduler.unstable_yieldValue(
+          'componentDidMount:' + this.state.x + '-' + this.props.x,
+        );
       }
       render() {
         return <span />;
@@ -1243,12 +1168,12 @@ describe('ReactIncremental', () => {
     }
 
     function Trail() {
-      ops.push('Trail');
+      Scheduler.unstable_yieldValue('Trail');
       return null;
     }
 
     function App(props) {
-      ops.push('App');
+      Scheduler.unstable_yieldValue('App');
       return (
         <div>
           <LifeCycle x={props.x} />
@@ -1260,14 +1185,10 @@ describe('ReactIncremental', () => {
     ReactNoop.render(<App x={0} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(ops).toEqual(['App', 'componentWillMount:0-0']);
-
-    ops = [];
+    expect(Scheduler).toHaveYielded(['App', 'componentWillMount:0-0']);
 
     ReactNoop.render(<App x={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'App',
       'componentWillReceiveProps:0-1',
       'componentWillMount:1-1',
@@ -1277,45 +1198,40 @@ describe('ReactIncremental', () => {
   });
 
   xit('uses state set in componentWillMount even if initial render was aborted', () => {
-    let ops = [];
-
     class LifeCycle extends React.Component {
       constructor(props) {
         super(props);
         this.state = {x: this.props.x + '(ctor)'};
       }
       UNSAFE_componentWillMount() {
-        ops.push('componentWillMount:' + this.state.x);
+        Scheduler.unstable_yieldValue('componentWillMount:' + this.state.x);
         this.setState({x: this.props.x + '(willMount)'});
       }
       componentDidMount() {
-        ops.push('componentDidMount:' + this.state.x);
+        Scheduler.unstable_yieldValue('componentDidMount:' + this.state.x);
       }
       render() {
-        ops.push('render:' + this.state.x);
+        Scheduler.unstable_yieldValue('render:' + this.state.x);
         return <span />;
       }
     }
 
     function App(props) {
-      ops.push('App');
+      Scheduler.unstable_yieldValue('App');
       return <LifeCycle x={props.x} />;
     }
 
     ReactNoop.render(<App x={0} />);
     ReactNoop.flushDeferredPri(20);
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'App',
       'componentWillMount:0(ctor)',
       'render:0(willMount)',
     ]);
 
-    ops = [];
     ReactNoop.render(<App x={1} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'App',
       'componentWillMount:0(willMount)',
       'render:1(willMount)',
@@ -1324,32 +1240,36 @@ describe('ReactIncremental', () => {
   });
 
   xit('calls componentWill* twice if an update render is aborted', () => {
-    let ops = [];
-
     class LifeCycle extends React.Component {
       UNSAFE_componentWillMount() {
-        ops.push('componentWillMount:' + this.props.x);
+        Scheduler.unstable_yieldValue('componentWillMount:' + this.props.x);
       }
       componentDidMount() {
-        ops.push('componentDidMount:' + this.props.x);
+        Scheduler.unstable_yieldValue('componentDidMount:' + this.props.x);
       }
       UNSAFE_componentWillReceiveProps(nextProps) {
-        ops.push(
+        Scheduler.unstable_yieldValue(
           'componentWillReceiveProps:' + this.props.x + '-' + nextProps.x,
         );
       }
       shouldComponentUpdate(nextProps) {
-        ops.push('shouldComponentUpdate:' + this.props.x + '-' + nextProps.x);
+        Scheduler.unstable_yieldValue(
+          'shouldComponentUpdate:' + this.props.x + '-' + nextProps.x,
+        );
         return true;
       }
       UNSAFE_componentWillUpdate(nextProps) {
-        ops.push('componentWillUpdate:' + this.props.x + '-' + nextProps.x);
+        Scheduler.unstable_yieldValue(
+          'componentWillUpdate:' + this.props.x + '-' + nextProps.x,
+        );
       }
       componentDidUpdate(prevProps) {
-        ops.push('componentDidUpdate:' + this.props.x + '-' + prevProps.x);
+        Scheduler.unstable_yieldValue(
+          'componentDidUpdate:' + this.props.x + '-' + prevProps.x,
+        );
       }
       render() {
-        ops.push('render:' + this.props.x);
+        Scheduler.unstable_yieldValue('render:' + this.props.x);
         return <span />;
       }
     }
@@ -1357,20 +1277,18 @@ describe('ReactIncremental', () => {
     function Sibling() {
       // The sibling is used to confirm that we've completed the first child,
       // but not yet flushed.
-      ops.push('Sibling');
+      Scheduler.unstable_yieldValue('Sibling');
       return <span />;
     }
 
     function App(props) {
-      ops.push('App');
+      Scheduler.unstable_yieldValue('App');
 
       return [<LifeCycle key="a" x={props.x} />, <Sibling key="b" />];
     }
 
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'App',
       'componentWillMount:0',
       'render:0',
@@ -1378,12 +1296,10 @@ describe('ReactIncremental', () => {
       'componentDidMount:0',
     ]);
 
-    ops = [];
-
     ReactNoop.render(<App x={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'App',
       'componentWillReceiveProps:0-1',
       'shouldComponentUpdate:0-1',
@@ -1393,12 +1309,8 @@ describe('ReactIncremental', () => {
       // no componentDidUpdate
     ]);
 
-    ops = [];
-
     ReactNoop.render(<App x={2} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'App',
       'componentWillReceiveProps:1-2',
       'shouldComponentUpdate:1-2',
@@ -1411,40 +1323,33 @@ describe('ReactIncremental', () => {
   });
 
   it('calls getDerivedStateFromProps even for state-only updates', () => {
-    let ops = [];
     let instance;
 
     class LifeCycle extends React.Component {
       state = {};
       static getDerivedStateFromProps(props, prevState) {
-        ops.push('getDerivedStateFromProps');
+        Scheduler.unstable_yieldValue('getDerivedStateFromProps');
         return {foo: 'foo'};
       }
       changeState() {
         this.setState({foo: 'bar'});
       }
       componentDidUpdate() {
-        ops.push('componentDidUpdate');
+        Scheduler.unstable_yieldValue('componentDidUpdate');
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         instance = this;
         return null;
       }
     }
 
     ReactNoop.render(<LifeCycle />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual(['getDerivedStateFromProps', 'render']);
+    expect(Scheduler).toFlushAndYield(['getDerivedStateFromProps', 'render']);
     expect(instance.state).toEqual({foo: 'foo'});
 
-    ops = [];
-
     instance.changeState();
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'getDerivedStateFromProps',
       'render',
       'componentDidUpdate',
@@ -1486,8 +1391,6 @@ describe('ReactIncremental', () => {
   });
 
   xit('does not call componentWillReceiveProps for state-only updates', () => {
-    let ops = [];
-
     const instances = [];
 
     class LifeCycle extends React.Component {
@@ -1499,26 +1402,32 @@ describe('ReactIncremental', () => {
       }
       UNSAFE_componentWillMount() {
         instances.push(this);
-        ops.push('componentWillMount:' + this.state.x);
+        Scheduler.unstable_yieldValue('componentWillMount:' + this.state.x);
       }
       componentDidMount() {
-        ops.push('componentDidMount:' + this.state.x);
+        Scheduler.unstable_yieldValue('componentDidMount:' + this.state.x);
       }
       UNSAFE_componentWillReceiveProps(nextProps) {
-        ops.push('componentWillReceiveProps');
+        Scheduler.unstable_yieldValue('componentWillReceiveProps');
       }
       shouldComponentUpdate(nextProps, nextState) {
-        ops.push('shouldComponentUpdate:' + this.state.x + '-' + nextState.x);
+        Scheduler.unstable_yieldValue(
+          'shouldComponentUpdate:' + this.state.x + '-' + nextState.x,
+        );
         return true;
       }
       UNSAFE_componentWillUpdate(nextProps, nextState) {
-        ops.push('componentWillUpdate:' + this.state.x + '-' + nextState.x);
+        Scheduler.unstable_yieldValue(
+          'componentWillUpdate:' + this.state.x + '-' + nextState.x,
+        );
       }
       componentDidUpdate(prevProps, prevState) {
-        ops.push('componentDidUpdate:' + this.state.x + '-' + prevState.x);
+        Scheduler.unstable_yieldValue(
+          'componentDidUpdate:' + this.state.x + '-' + prevState.x,
+        );
       }
       render() {
-        ops.push('render:' + this.state.x);
+        Scheduler.unstable_yieldValue('render:' + this.state.x);
         return <span />;
       }
     }
@@ -1537,7 +1446,7 @@ describe('ReactIncremental', () => {
         });
       }
       render() {
-        ops.push('Wrap');
+        Scheduler.unstable_yieldValue('Wrap');
         return <LifeCycle y={this.state.y} />;
       }
     }
@@ -1545,19 +1454,17 @@ describe('ReactIncremental', () => {
     function Sibling() {
       // The sibling is used to confirm that we've completed the first child,
       // but not yet flushed.
-      ops.push('Sibling');
+      Scheduler.unstable_yieldValue('Sibling');
       return <span />;
     }
 
     function App(props) {
-      ops.push('App');
+      Scheduler.unstable_yieldValue('App');
       return [<Wrap key="a" />, <Sibling key="b" />];
     }
 
     ReactNoop.render(<App y={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'App',
       'Wrap',
       'componentWillMount:0',
@@ -1566,14 +1473,12 @@ describe('ReactIncremental', () => {
       'componentDidMount:0',
     ]);
 
-    ops = [];
-
     // LifeCycle
     instances[1].tick();
 
     ReactNoop.flushDeferredPri(25);
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       // no componentWillReceiveProps
       'shouldComponentUpdate:0-1',
       'componentWillUpdate:0-1',
@@ -1581,14 +1486,10 @@ describe('ReactIncremental', () => {
       // no componentDidUpdate
     ]);
 
-    ops = [];
-
     // LifeCycle
     instances[1].tick();
 
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       // no componentWillReceiveProps
       'shouldComponentUpdate:1-2',
       'componentWillUpdate:1-2',
@@ -1597,15 +1498,13 @@ describe('ReactIncremental', () => {
       'componentDidUpdate:2-0',
     ]);
 
-    ops = [];
-
     // Next we will update props of LifeCycle by updating its parent.
 
     instances[0].tick();
 
     ReactNoop.flushDeferredPri(30);
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'Wrap',
       'componentWillReceiveProps',
       'shouldComponentUpdate:2-2',
@@ -1614,14 +1513,10 @@ describe('ReactIncremental', () => {
       // no componentDidUpdate
     ]);
 
-    ops = [];
-
     // Next we will update LifeCycle directly but not with new props.
     instances[1].tick();
 
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       // This should not trigger another componentWillReceiveProps because
       // we never got new props.
       'shouldComponentUpdate:2-3',
@@ -1635,37 +1530,35 @@ describe('ReactIncremental', () => {
   });
 
   xit('skips will/DidUpdate when bailing unless an update was already in progress', () => {
-    let ops = [];
-
     class LifeCycle extends React.Component {
       UNSAFE_componentWillMount() {
-        ops.push('componentWillMount');
+        Scheduler.unstable_yieldValue('componentWillMount');
       }
       componentDidMount() {
-        ops.push('componentDidMount');
+        Scheduler.unstable_yieldValue('componentDidMount');
       }
       UNSAFE_componentWillReceiveProps(nextProps) {
-        ops.push('componentWillReceiveProps');
+        Scheduler.unstable_yieldValue('componentWillReceiveProps');
       }
       shouldComponentUpdate(nextProps) {
-        ops.push('shouldComponentUpdate');
+        Scheduler.unstable_yieldValue('shouldComponentUpdate');
         // Bail
         return this.props.x !== nextProps.x;
       }
       UNSAFE_componentWillUpdate(nextProps) {
-        ops.push('componentWillUpdate');
+        Scheduler.unstable_yieldValue('componentWillUpdate');
       }
       componentDidUpdate(prevProps) {
-        ops.push('componentDidUpdate');
+        Scheduler.unstable_yieldValue('componentDidUpdate');
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         return <span />;
       }
     }
 
     function Sibling() {
-      ops.push('render sibling');
+      Scheduler.unstable_yieldValue('render sibling');
       return <span />;
     }
 
@@ -1674,22 +1567,16 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'componentWillMount',
       'render',
       'render sibling',
       'componentDidMount',
     ]);
 
-    ops = [];
-
     // Update to same props
     ReactNoop.render(<App x={0} />);
-    expect(Scheduler).toFlushWithoutYielding();
-
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       // no componentWillUpdate
@@ -1698,13 +1585,11 @@ describe('ReactIncremental', () => {
       // no componentDidUpdate
     ]);
 
-    ops = [];
-
     // Begin updating to new props...
     ReactNoop.render(<App x={1} />);
     ReactNoop.flushDeferredPri(30);
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       'componentWillUpdate',
@@ -1713,14 +1598,12 @@ describe('ReactIncremental', () => {
       // no componentDidUpdate yet
     ]);
 
-    ops = [];
-
     // ...but we'll interrupt it to rerender the same props.
     ReactNoop.render(<App x={1} />);
     expect(Scheduler).toFlushWithoutYielding();
 
     // We can bail out this time, but we must call componentDidUpdate.
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'componentWillReceiveProps',
       'shouldComponentUpdate',
       // no componentWillUpdate
@@ -1731,7 +1614,6 @@ describe('ReactIncremental', () => {
   });
 
   it('can nest batchedUpdates', () => {
-    let ops = [];
     let instance;
 
     class Foo extends React.Component {
@@ -1744,24 +1626,31 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Foo />);
     expect(Scheduler).toFlushWithoutYielding();
-    ops = [];
 
     ReactNoop.flushSync(() => {
       ReactNoop.batchedUpdates(() => {
-        instance.setState({n: 1}, () => ops.push('setState 1'));
-        instance.setState({n: 2}, () => ops.push('setState 2'));
+        instance.setState({n: 1}, () =>
+          Scheduler.unstable_yieldValue('setState 1'),
+        );
+        instance.setState({n: 2}, () =>
+          Scheduler.unstable_yieldValue('setState 2'),
+        );
         ReactNoop.batchedUpdates(() => {
-          instance.setState({n: 3}, () => ops.push('setState 3'));
-          instance.setState({n: 4}, () => ops.push('setState 4'));
-          ops.push('end inner batchedUpdates');
+          instance.setState({n: 3}, () =>
+            Scheduler.unstable_yieldValue('setState 3'),
+          );
+          instance.setState({n: 4}, () =>
+            Scheduler.unstable_yieldValue('setState 4'),
+          );
+          Scheduler.unstable_yieldValue('end inner batchedUpdates');
         });
-        ops.push('end outer batchedUpdates');
+        Scheduler.unstable_yieldValue('end outer batchedUpdates');
       });
     });
 
     // ReactNoop.flush() not needed because updates are synchronous
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'end inner batchedUpdates',
       'end outer batchedUpdates',
       'setState 1',
@@ -1773,7 +1662,6 @@ describe('ReactIncremental', () => {
   });
 
   it('can handle if setState callback throws', () => {
-    let ops = [];
     let instance;
 
     class Foo extends React.Component {
@@ -1786,25 +1674,28 @@ describe('ReactIncremental', () => {
 
     ReactNoop.render(<Foo />);
     expect(Scheduler).toFlushWithoutYielding();
-    ops = [];
 
     function updater({n}) {
       return {n: n + 1};
     }
 
-    instance.setState(updater, () => ops.push('first callback'));
+    instance.setState(updater, () =>
+      Scheduler.unstable_yieldValue('first callback'),
+    );
     instance.setState(updater, () => {
-      ops.push('second callback');
+      Scheduler.unstable_yieldValue('second callback');
       throw new Error('callback error');
     });
-    instance.setState(updater, () => ops.push('third callback'));
+    instance.setState(updater, () =>
+      Scheduler.unstable_yieldValue('third callback'),
+    );
 
     expect(() => {
       expect(Scheduler).toFlushWithoutYielding();
     }).toThrow('callback error');
 
     // The third callback isn't called because the second one throws
-    expect(ops).toEqual(['first callback', 'second callback']);
+    expect(Scheduler).toHaveYielded(['first callback', 'second callback']);
     expect(instance.state.n).toEqual(3);
   });
 
@@ -1977,7 +1868,6 @@ describe('ReactIncremental', () => {
   });
 
   it('does not leak own context into context provider', () => {
-    const ops = [];
     class Recurse extends React.Component {
       static contextTypes = {
         n: PropTypes.number,
@@ -1989,7 +1879,9 @@ describe('ReactIncremental', () => {
         return {n: (this.context.n || 3) - 1};
       }
       render() {
-        ops.push('Recurse ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'Recurse ' + JSON.stringify(this.context),
+        );
         if (this.context.n === 0) {
           return null;
         }
@@ -1998,30 +1890,30 @@ describe('ReactIncremental', () => {
     }
 
     ReactNoop.render(<Recurse />);
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield([
+        'Recurse {}',
+        'Recurse {"n":2}',
+        'Recurse {"n":1}',
+        'Recurse {"n":0}',
+      ]),
+    ).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Recurse',
     );
-    expect(ops).toEqual([
-      'Recurse {}',
-      'Recurse {"n":2}',
-      'Recurse {"n":1}',
-      'Recurse {"n":0}',
-    ]);
   });
 
   if (!require('shared/ReactFeatureFlags').disableModulePatternComponents) {
     it('does not leak own context into context provider (factory components)', () => {
-      const ops = [];
       function Recurse(props, context) {
         return {
           getChildContext() {
             return {n: (context.n || 3) - 1};
           },
           render() {
-            ops.push('Recurse ' + JSON.stringify(context));
+            Scheduler.unstable_yieldValue('Recurse ' + JSON.stringify(context));
             if (context.n === 0) {
               return null;
             }
@@ -2037,7 +1929,14 @@ describe('ReactIncremental', () => {
       };
 
       ReactNoop.render(<Recurse />);
-      expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev([
+      expect(() =>
+        expect(Scheduler).toFlushAndYield([
+          'Recurse {}',
+          'Recurse {"n":2}',
+          'Recurse {"n":1}',
+          'Recurse {"n":0}',
+        ]),
+      ).toErrorDev([
         'Warning: The <Recurse /> component appears to be a function component that returns a class instance. ' +
           'Change Recurse to a class that extends React.Component instead. ' +
           "If you can't use a class try assigning the prototype on the function as a workaround. " +
@@ -2048,12 +1947,6 @@ describe('ReactIncremental', () => {
           'using it should migrate to the new version.\n\n' +
           'Please update the following components: Recurse',
       ]);
-      expect(ops).toEqual([
-        'Recurse {}',
-        'Recurse {"n":2}',
-        'Recurse {"n":1}',
-        'Recurse {"n":0}',
-      ]);
     });
   }
 
@@ -2118,7 +2011,6 @@ describe('ReactIncremental', () => {
   });
 
   it('reads context when setState is below the provider', () => {
-    const ops = [];
     let statefulInst;
 
     class Intl extends React.Component {
@@ -2129,11 +2021,15 @@ describe('ReactIncremental', () => {
         const childContext = {
           locale: this.props.locale,
         };
-        ops.push('Intl:provide ' + JSON.stringify(childContext));
+        Scheduler.unstable_yieldValue(
+          'Intl:provide ' + JSON.stringify(childContext),
+        );
         return childContext;
       }
       render() {
-        ops.push('Intl:read ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'Intl:read ' + JSON.stringify(this.context),
+        );
         return this.props.children;
       }
     }
@@ -2143,13 +2039,17 @@ describe('ReactIncremental', () => {
         locale: PropTypes.string,
       };
       render() {
-        ops.push('ShowLocaleClass:read ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'ShowLocaleClass:read ' + JSON.stringify(this.context),
+        );
         return this.context.locale;
       }
     }
 
     function ShowLocaleFn(props, context) {
-      ops.push('ShowLocaleFn:read ' + JSON.stringify(context));
+      Scheduler.unstable_yieldValue(
+        'ShowLocaleFn:read ' + JSON.stringify(context),
+      );
       return context.locale;
     }
     ShowLocaleFn.contextTypes = {
@@ -2165,18 +2065,19 @@ describe('ReactIncremental', () => {
     }
 
     function IndirectionFn(props, context) {
-      ops.push('IndirectionFn ' + JSON.stringify(context));
+      Scheduler.unstable_yieldValue('IndirectionFn ' + JSON.stringify(context));
       return props.children;
     }
 
     class IndirectionClass extends React.Component {
       render() {
-        ops.push('IndirectionClass ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'IndirectionClass ' + JSON.stringify(this.context),
+        );
         return this.props.children;
       }
     }
 
-    ops.length = 0;
     ReactNoop.render(
       <Intl locale="fr">
         <IndirectionFn>
@@ -2189,31 +2090,30 @@ describe('ReactIncremental', () => {
         </IndirectionFn>
       </Intl>,
     );
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield([
+        'Intl:read {}',
+        'Intl:provide {"locale":"fr"}',
+        'IndirectionFn {}',
+        'IndirectionClass {}',
+        'ShowLocaleClass:read {"locale":"fr"}',
+        'ShowLocaleFn:read {"locale":"fr"}',
+      ]),
+    ).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Intl, ShowLocaleClass, ShowLocaleFn',
     );
-    expect(ops).toEqual([
-      'Intl:read {}',
-      'Intl:provide {"locale":"fr"}',
-      'IndirectionFn {}',
-      'IndirectionClass {}',
-      'ShowLocaleClass:read {"locale":"fr"}',
-      'ShowLocaleFn:read {"locale":"fr"}',
-    ]);
 
-    ops.length = 0;
     statefulInst.setState({x: 1});
     expect(Scheduler).toFlushWithoutYielding();
     // All work has been memoized because setState()
     // happened below the context and could not have affected it.
-    expect(ops).toEqual([]);
+    expect(Scheduler).toHaveYielded([]);
   });
 
   it('reads context when setState is above the provider', () => {
-    const ops = [];
     let statefulInst;
 
     class Intl extends React.Component {
@@ -2224,11 +2124,15 @@ describe('ReactIncremental', () => {
         const childContext = {
           locale: this.props.locale,
         };
-        ops.push('Intl:provide ' + JSON.stringify(childContext));
+        Scheduler.unstable_yieldValue(
+          'Intl:provide ' + JSON.stringify(childContext),
+        );
         return childContext;
       }
       render() {
-        ops.push('Intl:read ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'Intl:read ' + JSON.stringify(this.context),
+        );
         return this.props.children;
       }
     }
@@ -2238,13 +2142,17 @@ describe('ReactIncremental', () => {
         locale: PropTypes.string,
       };
       render() {
-        ops.push('ShowLocaleClass:read ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'ShowLocaleClass:read ' + JSON.stringify(this.context),
+        );
         return this.context.locale;
       }
     }
 
     function ShowLocaleFn(props, context) {
-      ops.push('ShowLocaleFn:read ' + JSON.stringify(context));
+      Scheduler.unstable_yieldValue(
+        'ShowLocaleFn:read ' + JSON.stringify(context),
+      );
       return context.locale;
     }
     ShowLocaleFn.contextTypes = {
@@ -2252,13 +2160,15 @@ describe('ReactIncremental', () => {
     };
 
     function IndirectionFn(props, context) {
-      ops.push('IndirectionFn ' + JSON.stringify(context));
+      Scheduler.unstable_yieldValue('IndirectionFn ' + JSON.stringify(context));
       return props.children;
     }
 
     class IndirectionClass extends React.Component {
       render() {
-        ops.push('IndirectionClass ' + JSON.stringify(this.context));
+        Scheduler.unstable_yieldValue(
+          'IndirectionClass ' + JSON.stringify(this.context),
+        );
         return this.props.children;
       }
     }
@@ -2271,7 +2181,6 @@ describe('ReactIncremental', () => {
       }
     }
 
-    ops.length = 0;
     ReactNoop.render(
       <Stateful>
         <IndirectionFn>
@@ -2282,25 +2191,24 @@ describe('ReactIncremental', () => {
         </IndirectionFn>
       </Stateful>,
     );
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield([
+        'Intl:read {}',
+        'Intl:provide {"locale":"fr"}',
+        'IndirectionFn {}',
+        'IndirectionClass {}',
+        'ShowLocaleClass:read {"locale":"fr"}',
+        'ShowLocaleFn:read {"locale":"fr"}',
+      ]),
+    ).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Intl, ShowLocaleClass, ShowLocaleFn',
     );
-    expect(ops).toEqual([
-      'Intl:read {}',
-      'Intl:provide {"locale":"fr"}',
-      'IndirectionFn {}',
-      'IndirectionClass {}',
-      'ShowLocaleClass:read {"locale":"fr"}',
-      'ShowLocaleFn:read {"locale":"fr"}',
-    ]);
 
-    ops.length = 0;
     statefulInst.setState({locale: 'gr'});
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       // Intl is below setState() so it might have been
       // affected by it. Therefore we re-render and recompute
       // its child context.
@@ -2421,38 +2329,47 @@ describe('ReactIncremental', () => {
   });
 
   it('should not recreate masked context unless inputs have changed', () => {
-    const ops = [];
-
     let scuCounter = 0;
 
     class MyComponent extends React.Component {
       static contextTypes = {};
       componentDidMount(prevProps, prevState) {
-        ops.push('componentDidMount');
+        Scheduler.unstable_yieldValue('componentDidMount');
         this.setState({setStateInCDU: true});
       }
       componentDidUpdate(prevProps, prevState) {
-        ops.push('componentDidUpdate');
+        Scheduler.unstable_yieldValue('componentDidUpdate');
         if (this.state.setStateInCDU) {
           this.setState({setStateInCDU: false});
         }
       }
       UNSAFE_componentWillReceiveProps(nextProps) {
-        ops.push('componentWillReceiveProps');
+        Scheduler.unstable_yieldValue('componentWillReceiveProps');
         this.setState({setStateInCDU: true});
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         return null;
       }
       shouldComponentUpdate(nextProps, nextState) {
-        ops.push('shouldComponentUpdate');
+        Scheduler.unstable_yieldValue('shouldComponentUpdate');
         return scuCounter++ < 5; // Don't let test hang
       }
     }
 
     ReactNoop.render(<MyComponent />);
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield([
+        'render',
+        'componentDidMount',
+        'shouldComponentUpdate',
+        'render',
+        'componentDidUpdate',
+        'shouldComponentUpdate',
+        'render',
+        'componentDidUpdate',
+      ]),
+    ).toErrorDev(
       [
         'Using UNSAFE_componentWillReceiveProps in strict mode is not recommended',
         'Legacy context API has been detected within a strict-mode tree.\n\n' +
@@ -2462,17 +2379,6 @@ describe('ReactIncremental', () => {
       ],
       {withoutStack: 1},
     );
-
-    expect(ops).toEqual([
-      'render',
-      'componentDidMount',
-      'shouldComponentUpdate',
-      'render',
-      'componentDidUpdate',
-      'shouldComponentUpdate',
-      'render',
-      'componentDidUpdate',
-    ]);
   });
 
   xit('should reuse memoized work if pointers are updated before calling lifecycles', () => {
@@ -2559,7 +2465,6 @@ describe('ReactIncremental', () => {
   });
 
   it('updates descendants with new context values', () => {
-    const rendered = [];
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2590,7 +2495,7 @@ describe('ReactIncremental', () => {
         count: PropTypes.number,
       };
       render = () => {
-        rendered.push(`count:${this.context.count}`);
+        Scheduler.unstable_yieldValue(`count:${this.context.count}`);
         return null;
       };
     }
@@ -2603,20 +2508,17 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() => expect(Scheduler).toFlushAndYield(['count:0'])).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Child, TopContextProvider',
     );
-    expect(rendered).toEqual(['count:0']);
     instance.updateCount();
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(rendered).toEqual(['count:0', 'count:1']);
+    expect(Scheduler).toFlushAndYield(['count:1']);
   });
 
   it('updates descendants with multiple context-providing ancestors with new context values', () => {
-    const rendered = [];
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2653,7 +2555,7 @@ describe('ReactIncremental', () => {
         count: PropTypes.number,
       };
       render = () => {
-        rendered.push(`count:${this.context.count}`);
+        Scheduler.unstable_yieldValue(`count:${this.context.count}`);
         return null;
       };
     }
@@ -2666,20 +2568,17 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() => expect(Scheduler).toFlushAndYield(['count:0'])).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Child, MiddleContextProvider, TopContextProvider',
     );
-    expect(rendered).toEqual(['count:0']);
     instance.updateCount();
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(rendered).toEqual(['count:0', 'count:1']);
+    expect(Scheduler).toFlushAndYield(['count:1']);
   });
 
   it('should not update descendants with new context values if shouldComponentUpdate returns false', () => {
-    const rendered = [];
     let instance;
 
     class TopContextProvider extends React.Component {
@@ -2723,7 +2622,7 @@ describe('ReactIncremental', () => {
         count: PropTypes.number,
       };
       render = () => {
-        rendered.push(`count:${this.context.count}`);
+        Scheduler.unstable_yieldValue(`count:${this.context.count}`);
         return null;
       };
     }
@@ -2738,20 +2637,17 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() => expect(Scheduler).toFlushAndYield(['count:0'])).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Child, MiddleContextProvider, TopContextProvider',
     );
-    expect(rendered).toEqual(['count:0']);
     instance.updateCount();
     expect(Scheduler).toFlushWithoutYielding();
-    expect(rendered).toEqual(['count:0']);
   });
 
   it('should update descendants with new context values if setState() is called in the middle of the tree', () => {
-    const rendered = [];
     let middleInstance;
     let topInstance;
 
@@ -2805,7 +2701,9 @@ describe('ReactIncremental', () => {
         name: PropTypes.string,
       };
       render = () => {
-        rendered.push(`count:${this.context.count}, name:${this.context.name}`);
+        Scheduler.unstable_yieldValue(
+          `count:${this.context.count}, name:${this.context.name}`,
+        );
         return null;
       };
     }
@@ -2820,22 +2718,18 @@ describe('ReactIncremental', () => {
       </TopContextProvider>,
     );
 
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield(['count:0, name:brian']),
+    ).toErrorDev(
       'Legacy context API has been detected within a strict-mode tree.\n\n' +
         'The old API will be supported in all 16.x releases, but applications ' +
         'using it should migrate to the new version.\n\n' +
         'Please update the following components: Child, MiddleContextProvider, TopContextProvider',
     );
-    expect(rendered).toEqual(['count:0, name:brian']);
     topInstance.updateCount();
     expect(Scheduler).toFlushWithoutYielding();
-    expect(rendered).toEqual(['count:0, name:brian']);
     middleInstance.updateName('not brian');
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(rendered).toEqual([
-      'count:0, name:brian',
-      'count:1, name:not brian',
-    ]);
+    expect(Scheduler).toFlushAndYield(['count:1, name:not brian']);
   });
 
   it('does not interrupt for update at same priority', () => {
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
index 8eebd6e3a6..4ba335869e 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalErrorHandling-test.internal.js
@@ -20,7 +20,6 @@ describe('ReactIncrementalErrorHandling', () => {
   beforeEach(() => {
     jest.resetModules();
     ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
     ReactFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback = false;
     PropTypes = require('prop-types');
     React = require('react');
@@ -554,27 +553,26 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('catches render error in a boundary during synchronous mounting', () => {
-    const ops = [];
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
-        ops.push('ErrorBoundary componentDidCatch');
+        Scheduler.unstable_yieldValue('ErrorBoundary componentDidCatch');
         this.setState({error});
       }
       render() {
         if (this.state.error) {
-          ops.push('ErrorBoundary render error');
+          Scheduler.unstable_yieldValue('ErrorBoundary render error');
           return (
             <span prop={`Caught an error: ${this.state.error.message}.`} />
           );
         }
-        ops.push('ErrorBoundary render success');
+        Scheduler.unstable_yieldValue('ErrorBoundary render success');
         return this.props.children;
       }
     }
 
     function BrokenRender(props) {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
@@ -586,7 +584,7 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'ErrorBoundary render success',
       'BrokenRender',
 
@@ -602,27 +600,26 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('catches render error in a boundary during batched mounting', () => {
-    const ops = [];
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
-        ops.push('ErrorBoundary componentDidCatch');
+        Scheduler.unstable_yieldValue('ErrorBoundary componentDidCatch');
         this.setState({error});
       }
       render() {
         if (this.state.error) {
-          ops.push('ErrorBoundary render error');
+          Scheduler.unstable_yieldValue('ErrorBoundary render error');
           return (
             <span prop={`Caught an error: ${this.state.error.message}.`} />
           );
         }
-        ops.push('ErrorBoundary render success');
+        Scheduler.unstable_yieldValue('ErrorBoundary render success');
         return this.props.children;
       }
     }
 
     function BrokenRender(props) {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
@@ -635,7 +632,7 @@ describe('ReactIncrementalErrorHandling', () => {
       );
     });
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'ErrorBoundary render success',
       'BrokenRender',
 
@@ -651,20 +648,19 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('propagates an error from a noop error boundary during full deferred mounting', () => {
-    const ops = [];
     class RethrowErrorBoundary extends React.Component {
       componentDidCatch(error) {
-        ops.push('RethrowErrorBoundary componentDidCatch');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary componentDidCatch');
         throw error;
       }
       render() {
-        ops.push('RethrowErrorBoundary render');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary render');
         return this.props.children;
       }
     }
 
     function BrokenRender() {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
@@ -675,19 +671,18 @@ describe('ReactIncrementalErrorHandling', () => {
     );
 
     expect(() => {
-      expect(Scheduler).toFlushWithoutYielding();
+      expect(Scheduler).toFlushAndYield([
+        'RethrowErrorBoundary render',
+        'BrokenRender',
+
+        // React retries one more time
+        'RethrowErrorBoundary render',
+        'BrokenRender',
+
+        // Errored again on retry. Now handle it.
+        'RethrowErrorBoundary componentDidCatch',
+      ]);
     }).toThrow('Hello');
-    expect(ops).toEqual([
-      'RethrowErrorBoundary render',
-      'BrokenRender',
-
-      // React retries one more time
-      'RethrowErrorBoundary render',
-      'BrokenRender',
-
-      // Errored again on retry. Now handle it.
-      'RethrowErrorBoundary componentDidCatch',
-    ]);
     expect(ReactNoop.getChildren()).toEqual([]);
   });
 
@@ -733,20 +728,19 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('propagates an error from a noop error boundary during synchronous mounting', () => {
-    const ops = [];
     class RethrowErrorBoundary extends React.Component {
       componentDidCatch(error) {
-        ops.push('RethrowErrorBoundary componentDidCatch');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary componentDidCatch');
         throw error;
       }
       render() {
-        ops.push('RethrowErrorBoundary render');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary render');
         return this.props.children;
       }
     }
 
     function BrokenRender() {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
@@ -759,7 +753,7 @@ describe('ReactIncrementalErrorHandling', () => {
         );
       });
     }).toThrow('Hello');
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'RethrowErrorBoundary render',
       'BrokenRender',
 
@@ -774,20 +768,19 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('propagates an error from a noop error boundary during batched mounting', () => {
-    const ops = [];
     class RethrowErrorBoundary extends React.Component {
       componentDidCatch(error) {
-        ops.push('RethrowErrorBoundary componentDidCatch');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary componentDidCatch');
         throw error;
       }
       render() {
-        ops.push('RethrowErrorBoundary render');
+        Scheduler.unstable_yieldValue('RethrowErrorBoundary render');
         return this.props.children;
       }
     }
 
     function BrokenRender() {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
@@ -803,7 +796,7 @@ describe('ReactIncrementalErrorHandling', () => {
         );
       });
     }).toThrow('Hello');
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'RethrowErrorBoundary render',
       'BrokenRender',
 
@@ -864,15 +857,13 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('can schedule updates after uncaught error in render on mount', () => {
-    let ops = [];
-
     function BrokenRender() {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       throw new Error('Hello');
     }
 
     function Foo() {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return null;
     }
 
@@ -880,23 +871,19 @@ describe('ReactIncrementalErrorHandling', () => {
     expect(() => {
       expect(Scheduler).toFlushWithoutYielding();
     }).toThrow('Hello');
-    expect(ops).toEqual([
+    ReactNoop.render(<Foo />);
+    expect(Scheduler).toHaveYielded([
       'BrokenRender',
       // React retries one more time
       'BrokenRender',
       // Errored again on retry
     ]);
-    ops = [];
-    ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo']);
+    expect(Scheduler).toFlushAndYield(['Foo']);
   });
 
   it('can schedule updates after uncaught error in render on update', () => {
-    let ops = [];
-
     function BrokenRender(props) {
-      ops.push('BrokenRender');
+      Scheduler.unstable_yieldValue('BrokenRender');
       if (props.throw) {
         throw new Error('Hello');
       }
@@ -904,34 +891,29 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     function Foo() {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return null;
     }
 
     ReactNoop.render(<BrokenRender throw={false} />);
-    expect(Scheduler).toFlushWithoutYielding();
-    ops = [];
+    expect(Scheduler).toFlushAndYield(['BrokenRender']);
 
     expect(() => {
       ReactNoop.render(<BrokenRender throw={true} />);
       expect(Scheduler).toFlushWithoutYielding();
     }).toThrow('Hello');
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'BrokenRender',
       // React retries one more time
       'BrokenRender',
       // Errored again on retry
     ]);
 
-    ops = [];
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo']);
+    expect(Scheduler).toFlushAndYield(['Foo']);
   });
 
   it('can schedule updates after uncaught error during umounting', () => {
-    let ops = [];
-
     class BrokenComponentWillUnmount extends React.Component {
       render() {
         return <div />;
@@ -942,7 +924,7 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     function Foo() {
-      ops.push('Foo');
+      Scheduler.unstable_yieldValue('Foo');
       return null;
     }
 
@@ -954,10 +936,8 @@ describe('ReactIncrementalErrorHandling', () => {
       expect(Scheduler).toFlushWithoutYielding();
     }).toThrow('Hello');
 
-    ops = [];
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['Foo']);
+    expect(Scheduler).toFlushAndYield(['Foo']);
   });
 
   it('should not attempt to recover an unmounting error boundary', () => {
@@ -1342,13 +1322,14 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('unmounts components with uncaught errors', () => {
-    const ops = [];
     let inst;
 
     class BrokenRenderAndUnmount extends React.Component {
       state = {fail: false};
       componentWillUnmount() {
-        ops.push('BrokenRenderAndUnmount componentWillUnmount');
+        Scheduler.unstable_yieldValue(
+          'BrokenRenderAndUnmount componentWillUnmount',
+        );
       }
       render() {
         inst = this;
@@ -1361,7 +1342,7 @@ describe('ReactIncrementalErrorHandling', () => {
 
     class Parent extends React.Component {
       componentWillUnmount() {
-        ops.push('Parent componentWillUnmount [!]');
+        Scheduler.unstable_yieldValue('Parent componentWillUnmount [!]');
         throw new Error('One does not simply unmount me.');
       }
       render() {
@@ -1383,7 +1364,7 @@ describe('ReactIncrementalErrorHandling', () => {
       expect(Scheduler).toFlushWithoutYielding();
     }).toThrowError('Hello.');
 
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       // Attempt to clean up.
       // Errors in parents shouldn't stop children from unmounting.
       'Parent componentWillUnmount [!]',
@@ -1394,11 +1375,9 @@ describe('ReactIncrementalErrorHandling', () => {
   });
 
   it('does not interrupt unmounting if detaching a ref throws', () => {
-    let ops = [];
-
     class Bar extends React.Component {
       componentWillUnmount() {
-        ops.push('Bar unmount');
+        Scheduler.unstable_yieldValue('Bar unmount');
       }
       render() {
         return <span prop="Bar" />;
@@ -1407,10 +1386,10 @@ describe('ReactIncrementalErrorHandling', () => {
 
     function barRef(inst) {
       if (inst === null) {
-        ops.push('barRef detach');
+        Scheduler.unstable_yieldValue('barRef detach');
         throw new Error('Detach error');
       }
-      ops.push('barRef attach');
+      Scheduler.unstable_yieldValue('barRef attach');
     }
 
     function Foo(props) {
@@ -1418,16 +1397,13 @@ describe('ReactIncrementalErrorHandling', () => {
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual(['barRef attach']);
+    expect(Scheduler).toFlushAndYield(['barRef attach']);
     expect(ReactNoop.getChildren()).toEqual([div(span('Bar'))]);
 
-    ops = [];
-
     // Unmount
     ReactNoop.render(<Foo hide={true} />);
     expect(Scheduler).toFlushAndThrow('Detach error');
-    expect(ops).toEqual([
+    expect(Scheduler).toHaveYielded([
       'barRef detach',
       // Bar should unmount even though its ref threw an error while detaching
       'Bar unmount',
@@ -1451,37 +1427,36 @@ describe('ReactIncrementalErrorHandling', () => {
   it('error boundaries capture non-errors', () => {
     spyOnProd(console, 'error');
     spyOnDev(console, 'error');
-    const ops = [];
 
     class ErrorBoundary extends React.Component {
       state = {error: null};
       componentDidCatch(error) {
         // Should not be called
-        ops.push('componentDidCatch');
+        Scheduler.unstable_yieldValue('componentDidCatch');
         this.setState({error});
       }
       render() {
         if (this.state.error) {
-          ops.push('ErrorBoundary (catch)');
+          Scheduler.unstable_yieldValue('ErrorBoundary (catch)');
           return (
             <span
               prop={`Caught an error: ${this.state.error.nonStandardMessage}`}
             />
           );
         }
-        ops.push('ErrorBoundary (try)');
+        Scheduler.unstable_yieldValue('ErrorBoundary (try)');
         return this.props.children;
       }
     }
 
     function Indirection(props) {
-      ops.push('Indirection');
+      Scheduler.unstable_yieldValue('Indirection');
       return props.children;
     }
 
     const notAnError = {nonStandardMessage: 'oops'};
     function BadRender() {
-      ops.push('BadRender');
+      Scheduler.unstable_yieldValue('BadRender');
       throw notAnError;
     }
 
@@ -1492,9 +1467,8 @@ describe('ReactIncrementalErrorHandling', () => {
         </Indirection>
       </ErrorBoundary>,
     );
-    expect(Scheduler).toFlushWithoutYielding();
 
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'ErrorBoundary (try)',
       'Indirection',
       'BadRender',
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js
similarity index 100%
rename from packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncrementalReflection-test.js
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
similarity index 96%
rename from packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
index f2b4d956d0..0fda09f04f 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalScheduling-test.js
@@ -11,15 +11,13 @@
 'use strict';
 
 let React;
-let ReactFeatureFlags;
 let ReactNoop;
 let Scheduler;
 
 describe('ReactIncrementalScheduling', () => {
   beforeEach(() => {
     jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
@@ -324,11 +322,10 @@ describe('ReactIncrementalScheduling', () => {
 
   it('nested updates are always deferred, even inside unbatchedUpdates', () => {
     let instance;
-    const ops = [];
     class Foo extends React.Component {
       state = {step: 0};
       componentDidUpdate() {
-        ops.push('componentDidUpdate: ' + this.state.step);
+        Scheduler.unstable_yieldValue('componentDidUpdate: ' + this.state.step);
         if (this.state.step === 1) {
           ReactNoop.unbatchedUpdates(() => {
             // This is a nested state update, so it should not be
@@ -336,30 +333,27 @@ describe('ReactIncrementalScheduling', () => {
             // in unbatchedUpdates.
             this.setState({step: 2});
           });
+          expect(Scheduler).toHaveYielded([
+            'render: 1',
+            'componentDidUpdate: 1',
+          ]);
           expect(ReactNoop).toMatchRenderedOutput(<span prop={1} />);
         }
       }
       render() {
-        ops.push('render: ' + this.state.step);
+        Scheduler.unstable_yieldValue('render: ' + this.state.step);
         instance = this;
         return <span prop={this.state.step} />;
       }
     }
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield(['render: 0']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={0} />);
 
     ReactNoop.flushSync(() => {
       instance.setState({step: 1});
     });
+    expect(Scheduler).toHaveYielded(['render: 2', 'componentDidUpdate: 2']);
     expect(ReactNoop).toMatchRenderedOutput(<span prop={2} />);
-
-    expect(ops).toEqual([
-      'render: 0',
-      'render: 1',
-      'componentDidUpdate: 1',
-      'render: 2',
-      'componentDidUpdate: 2',
-    ]);
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js
similarity index 100%
rename from packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncrementalSideEffects-test.js
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.js
similarity index 98%
rename from packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.js
index cd80343153..fdf7d37e82 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalTriangle-test.js
@@ -11,15 +11,13 @@
 'use strict';
 
 let React;
-let ReactFeatureFlags;
 let ReactNoop;
 let Scheduler;
 
 describe('ReactIncrementalTriangle', () => {
   beforeEach(() => {
     jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
@@ -184,12 +182,6 @@ describe('ReactIncrementalTriangle', () => {
     class Triangle extends React.Component {
       constructor(props) {
         super();
-        this.index = triangles.length;
-        triangles.push(this);
-        if (props.remainingDepth === 0) {
-          this.leafIndex = leafTriangles.length;
-          leafTriangles.push(this);
-        }
         this.state = {isActive: false};
         this.child = React.createRef(null);
       }
@@ -206,6 +198,14 @@ describe('ReactIncrementalTriangle', () => {
           this.state.isActive !== nextState.isActive
         );
       }
+      componentDidMount() {
+        this.index = triangles.length;
+        triangles.push(this);
+        if (this.props.remainingDepth === 0) {
+          this.leafIndex = leafTriangles.length;
+          leafTriangles.push(this);
+        }
+      }
       componentDidUpdate() {
         if (this.child.current !== null) {
           const {prop: currentCounter} = JSON.parse(this.child.current.prop);
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
similarity index 94%
rename from packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
index 74c206a927..51753f0e3f 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalUpdates-test.js
@@ -11,15 +11,13 @@
 'use strict';
 
 let React;
-let ReactFeatureFlags;
 let ReactNoop;
 let Scheduler;
 
 describe('ReactIncrementalUpdates', () => {
   beforeEach(() => {
     jest.resetModuleRegistry();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;
+
     React = require('react');
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
@@ -79,24 +77,23 @@ describe('ReactIncrementalUpdates', () => {
 
   it('only drops updates with equal or lesser priority when replaceState is called', () => {
     let instance;
-    let ops = [];
     class Foo extends React.Component {
       state = {};
       componentDidMount() {
-        ops.push('componentDidMount');
+        Scheduler.unstable_yieldValue('componentDidMount');
       }
       componentDidUpdate() {
-        ops.push('componentDidUpdate');
+        Scheduler.unstable_yieldValue('componentDidUpdate');
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         instance = this;
         return <div />;
       }
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield(['render', 'componentDidMount']);
 
     ReactNoop.flushSync(() => {
       ReactNoop.deferredUpdates(() => {
@@ -114,19 +111,11 @@ 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(ops).toEqual([
-      'render',
-      'componentDidMount',
-      'render',
-      'componentDidUpdate',
-    ]);
+    expect(Scheduler).toHaveYielded(['render', 'componentDidUpdate']);
 
-    ops = [];
-
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield(['render', 'componentDidUpdate']);
     // Now the rest of the updates are flushed, including the replaceState.
     expect(instance.state).toEqual({c: 'c', d: 'd'});
-    expect(ops).toEqual(['render', 'componentDidUpdate']);
   });
 
   it('can abort an update, schedule additional updates, and resume', () => {
@@ -298,27 +287,25 @@ describe('ReactIncrementalUpdates', () => {
   });
 
   it('does not call callbacks that are scheduled by another callback until a later commit', () => {
-    const ops = [];
     class Foo extends React.Component {
       state = {};
       componentDidMount() {
-        ops.push('did mount');
+        Scheduler.unstable_yieldValue('did mount');
         this.setState({a: 'a'}, () => {
-          ops.push('callback a');
+          Scheduler.unstable_yieldValue('callback a');
           this.setState({b: 'b'}, () => {
-            ops.push('callback b');
+            Scheduler.unstable_yieldValue('callback b');
           });
         });
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         return <div />;
       }
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
-    expect(ops).toEqual([
+    expect(Scheduler).toFlushAndYield([
       'render',
       'did mount',
       'render',
@@ -330,30 +317,27 @@ describe('ReactIncrementalUpdates', () => {
 
   it('gives setState during reconciliation the same priority as whatever level is currently reconciling', () => {
     let instance;
-    let ops = [];
 
     class Foo extends React.Component {
       state = {};
       UNSAFE_componentWillReceiveProps() {
-        ops.push('componentWillReceiveProps');
+        Scheduler.unstable_yieldValue('componentWillReceiveProps');
         this.setState({b: 'b'});
       }
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         instance = this;
         return <div />;
       }
     }
     ReactNoop.render(<Foo />);
     expect(() =>
-      expect(Scheduler).toFlushWithoutYielding(),
+      expect(Scheduler).toFlushAndYield(['render']),
     ).toErrorDev(
       'Using UNSAFE_componentWillReceiveProps in strict mode is not recommended',
       {withoutStack: true},
     );
 
-    ops = [];
-
     ReactNoop.flushSync(() => {
       instance.setState({a: 'a'});
 
@@ -361,44 +345,45 @@ describe('ReactIncrementalUpdates', () => {
     });
 
     expect(instance.state).toEqual({a: 'a', b: 'b'});
-    expect(ops).toEqual(['componentWillReceiveProps', 'render']);
+    expect(Scheduler).toHaveYielded(['componentWillReceiveProps', 'render']);
   });
 
   it('enqueues setState inside an updater function as if the in-progress update is progressed (and warns)', () => {
     let instance;
-    const ops = [];
     class Foo extends React.Component {
       state = {};
       render() {
-        ops.push('render');
+        Scheduler.unstable_yieldValue('render');
         instance = this;
         return <div />;
       }
     }
 
     ReactNoop.render(<Foo />);
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield([
+      // Initial render
+      'render',
+    ]);
 
     instance.setState(function a() {
-      ops.push('setState updater');
+      Scheduler.unstable_yieldValue('setState updater');
       this.setState({b: 'b'});
       return {a: 'a'};
     });
 
-    expect(() => expect(Scheduler).toFlushWithoutYielding()).toErrorDev(
+    expect(() =>
+      expect(Scheduler).toFlushAndYield([
+        'setState updater',
+        // Update b is enqueued with the same priority as update a, so it should
+        // be flushed in the same commit.
+        'render',
+      ]),
+    ).toErrorDev(
       'An update (setState, replaceState, or forceUpdate) was scheduled ' +
         'from inside an update function. Update functions should be pure, ' +
         'with zero side-effects. Consider using componentDidUpdate or a ' +
         'callback.',
     );
-    expect(ops).toEqual([
-      // Initial render
-      'render',
-      'setState updater',
-      // Update b is enqueued with the same priority as update a, so it should
-      // be flushed in the same commit.
-      'render',
-    ]);
     expect(instance.state).toEqual({a: 'a', b: 'b'});
 
     // Test deduplication (no additional warnings expected)
@@ -406,7 +391,7 @@ describe('ReactIncrementalUpdates', () => {
       this.setState({a: 'a'});
       return {b: 'b'};
     });
-    expect(Scheduler).toFlushWithoutYielding();
+    expect(Scheduler).toFlushAndYield(['render']);
   });
 
   it('getDerivedStateFromProps should update base state of updateQueue (based on product bug)', () => {
diff --git a/packages/react-reconciler/src/__tests__/ReactMemo-test.internal.js b/packages/react-reconciler/src/__tests__/ReactMemo-test.js
similarity index 100%
rename from packages/react-reconciler/src/__tests__/ReactMemo-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactMemo-test.js
diff --git a/packages/react-reconciler/src/__tests__/ReactNewContext-test.internal.js b/packages/react-reconciler/src/__tests__/ReactNewContext-test.js
similarity index 99%
rename from packages/react-reconciler/src/__tests__/ReactNewContext-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactNewContext-test.js
index 58609e6fc4..346d4e8d52 100644
--- a/packages/react-reconciler/src/__tests__/ReactNewContext-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactNewContext-test.js
@@ -1219,7 +1219,7 @@ describe('ReactNewContext', () => {
       spyOnDev(console, 'error');
       const Context = React.createContext(0);
       ReactNoop.render(<Context.Consumer />);
-      expect(Scheduler).toFlushAndThrow('render is not a function');
+      expect(Scheduler).toFlushAndThrow('is not a function');
       if (__DEV__) {
         expect(console.error.calls.argsFor(0)[0]).toContain(
           'A context consumer was rendered with multiple children, or a child ' +
diff --git a/packages/react-reconciler/src/__tests__/ReactSchedulerIntegration-test.internal.js b/packages/react-reconciler/src/__tests__/ReactSchedulerIntegration-test.js
similarity index 100%
rename from packages/react-reconciler/src/__tests__/ReactSchedulerIntegration-test.internal.js
rename to packages/react-reconciler/src/__tests__/ReactSchedulerIntegration-test.js
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRendererAsync-test.internal.js b/packages/react-test-renderer/src/__tests__/ReactTestRendererAsync-test.js
similarity index 100%
rename from packages/react-test-renderer/src/__tests__/ReactTestRendererAsync-test.internal.js
rename to packages/react-test-renderer/src/__tests__/ReactTestRendererAsync-test.js
diff --git a/packages/use-subscription/src/__tests__/useSubscription-test.internal.js b/packages/use-subscription/src/__tests__/useSubscription-test.js
similarity index 100%
rename from packages/use-subscription/src/__tests__/useSubscription-test.internal.js
rename to packages/use-subscription/src/__tests__/useSubscription-test.js