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