From 0ea3f2a060e285a71d3192a679432169fbf08e76 Mon Sep 17 00:00:00 2001
From: Andrew Clark <git@andrewclark.io>
Date: Tue, 1 Sep 2020 22:22:54 -0500
Subject: [PATCH] Decouple public, internal act implementation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In the next major release, we intend to drop support for using the `act`
testing helper in production. (It already fires a warning.) The
rationale is that, in order for `act` to work, you must either mock the
testing environment or add extra logic at runtime. Mocking the testing
environment isn't ideal because it requires extra set up for the user.
Extra logic at runtime is fine only in development mode — we don't want
to slow down the production builds.

Since most people only run their tests in development mode, dropping
support for production should be fine; if there's demand, we can add it
back later using a special testing build that is identical to the
production build except for the additional testing logic.

One blocker for removing production support is that we currently use
`act` to test React itself. We must test React in both development and
production modes.

So, the solution is to fork `act` into separate public and
internal implementations:

- *public implementation of `act`* – exposed to users, only works in
  development mode, uses special runtime logic, does not support partial
  rendering
- *internal implementation of `act`* – private, works in both
  development and productionm modes, only used by the React Core test
  suite, uses no special runtime logic, supports partial rendering (i.e.
  `toFlushAndYieldThrough`)

The internal implementation should mostly match the public
implementation's behavior, but since it's a private API, it doesn't have
to match exactly. It works by mocking the test environment: it uses a
mock build of Scheduler to flush rendering tasks, and Jest's mock timers
to flush Suspense placeholders.
---
 .../ReactHooksInspectionIntegration-test.js   |   2 +-
 .../__tests__/inspectedElementContext-test.js |  45 ++--
 .../__tests__/storeComponentFilters-test.js   |   2 +-
 .../src/__tests__/ReactDOMFiberAsync-test.js  |   2 +-
 .../ReactDOMServerIntegrationHooks-test.js    |  28 ++-
 ...DOMServerPartialHydration-test.internal.js |   2 +-
 ...MServerSelectiveHydration-test.internal.js |   4 +-
 .../ReactDOMServerSuspense-test.internal.js   |   4 +-
 .../ReactDOMSuspensePlaceholder-test.js       |   2 +-
 .../ReactErrorBoundaries-test.internal.js     |   2 +-
 .../src/__tests__/ReactTestUtilsAct-test.js   | 118 +++++----
 ...ReactTestUtilsActUnmockedScheduler-test.js |   5 +
 ...tUnmockedSchedulerWarning-test.internal.js |  56 -----
 .../ReactUnmockedSchedulerWarning-test.js     | 170 +++++++++----
 .../src/__tests__/ReactUpdates-test.js        |   2 +-
 .../ReactDOMServerIntegrationTestUtils.js     |   4 +-
 packages/react-dom/src/client/ReactDOM.js     |   3 +
 .../DOMPluginEventSystem-test.internal.js     |  10 +-
 .../__tests__/ChangeEventPlugin-test.js       |   2 +-
 .../src/test-utils/ReactTestUtils.js          |   5 +-
 .../src/test-utils/ReactTestUtilsAct.js       | 235 ++++++------------
 .../__tests__/useFocusWithin-test.internal.js |   2 +-
 .../src/createReactNoop.js                    | 121 ++++++++-
 .../src/ReactFiberReconciler.new.js           |   1 -
 .../src/ReactFiberReconciler.old.js           |   2 -
 .../src/ReactFiberWorkLoop.new.js             | 176 ++++++-------
 .../src/ReactFiberWorkLoop.old.js             | 176 ++++++-------
 .../src/SchedulerWithReactIntegration.new.js  |   7 +-
 .../src/__tests__/ReactBlocks-test.js         |  17 +-
 .../src/__tests__/ReactHooks-test.internal.js |  10 +-
 .../__tests__/ReactNoopRendererAct-test.js    |   1 -
 .../__tests__/ReactSuspense-test.internal.js  |   4 +-
 .../ReactSuspenseWithNoopRenderer-test.js     |  41 ++-
 .../SchedulingProfiler-test.internal.js       |   4 +-
 .../useMutableSourceHydration-test.js         |   2 +-
 .../src/__tests__/ReactFresh-test.js          |   4 +-
 .../__tests__/ReactFreshIntegration-test.js   |   2 +-
 .../src/ReactTestRenderer.js                  | 119 +++++++++
 .../__tests__/ReactTestRendererAct-test.js    |   4 +
 .../ReactFlightDOMRelay-test.internal.js      |   2 +-
 .../src/__tests__/ReactFlightDOM-test.js      |   2 +-
 .../ReactDOMTracing-test.internal.js          |  15 +-
 .../__tests__/ReactProfiler-test.internal.js  |  39 +--
 .../src/__tests__/useSubscription-test.js     |   2 +-
 scripts/jest/shouldIgnoreConsoleError.js      |  10 -
 45 files changed, 822 insertions(+), 644 deletions(-)
 delete mode 100644 packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.internal.js

diff --git a/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js b/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
index 01461dfc1648e..4dfe0bac0b1f1 100644
--- a/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
+++ b/packages/react-debug-tools/src/__tests__/ReactHooksInspectionIntegration-test.js
@@ -22,7 +22,7 @@ describe('ReactHooksInspectionIntegration', () => {
     React = require('react');
     ReactTestRenderer = require('react-test-renderer');
     Scheduler = require('scheduler');
-    act = ReactTestRenderer.act;
+    act = ReactTestRenderer.unstable_concurrentAct;
     ReactDebugTools = require('react-debug-tools');
   });
 
diff --git a/packages/react-devtools-shared/src/__tests__/inspectedElementContext-test.js b/packages/react-devtools-shared/src/__tests__/inspectedElementContext-test.js
index 29e8e379e4e43..a68de20ab0ee1 100644
--- a/packages/react-devtools-shared/src/__tests__/inspectedElementContext-test.js
+++ b/packages/react-devtools-shared/src/__tests__/inspectedElementContext-test.js
@@ -33,6 +33,9 @@ describe('InspectedElementContext', () => {
   let TestUtils;
   let TreeContextController;
 
+  let TestUtilsAct;
+  let TestRendererAct;
+
   beforeEach(() => {
     utils = require('./utils');
     utils.beforeEachProfiling();
@@ -47,7 +50,9 @@ describe('InspectedElementContext', () => {
     ReactDOM = require('react-dom');
     PropTypes = require('prop-types');
     TestUtils = require('react-dom/test-utils');
+    TestUtilsAct = TestUtils.unstable_concurrentAct;
     TestRenderer = utils.requireTestRenderer();
+    TestRendererAct = TestUtils.unstable_concurrentAct;
 
     BridgeContext = require('react-devtools-shared/src/devtools/views/context')
       .BridgeContext;
@@ -999,8 +1004,8 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('1: Initially inspect element');
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, ['props', 'nestedObject', 'a']);
         jest.runOnlyPendingTimers();
       });
@@ -1009,8 +1014,8 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('2: Inspect props.nestedObject.a');
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, ['props', 'nestedObject', 'a', 'b', 'c']);
         jest.runOnlyPendingTimers();
       });
@@ -1021,8 +1026,8 @@ describe('InspectedElementContext', () => {
     );
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, [
           'props',
           'nestedObject',
@@ -1041,8 +1046,8 @@ describe('InspectedElementContext', () => {
     );
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, ['hooks', 0, 'value']);
         jest.runOnlyPendingTimers();
       });
@@ -1051,8 +1056,8 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('5: Inspect hooks.0.value');
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, ['hooks', 0, 'value', 'foo', 'bar']);
         jest.runOnlyPendingTimers();
       });
@@ -1108,8 +1113,8 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('1: Initially inspect element');
 
     inspectedElement = null;
-    TestUtils.act(() => {
-      TestRenderer.act(() => {
+    TestUtilsAct(() => {
+      TestRendererAct(() => {
         getInspectedElementPath(id, ['props', 'set_of_sets', 0]);
         jest.runOnlyPendingTimers();
       });
@@ -1179,7 +1184,7 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('1: Initially inspect element');
 
     inspectedElement = null;
-    TestRenderer.act(() => {
+    TestRendererAct(() => {
       getInspectedElementPath(id, ['props', 'nestedObject', 'a']);
       jest.runOnlyPendingTimers();
     });
@@ -1187,15 +1192,15 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).toMatchSnapshot('2: Inspect props.nestedObject.a');
 
     inspectedElement = null;
-    TestRenderer.act(() => {
+    TestRendererAct(() => {
       getInspectedElementPath(id, ['props', 'nestedObject', 'c']);
       jest.runOnlyPendingTimers();
     });
     expect(inspectedElement).not.toBeNull();
     expect(inspectedElement).toMatchSnapshot('3: Inspect props.nestedObject.c');
 
-    TestRenderer.act(() => {
-      TestUtils.act(() => {
+    TestRendererAct(() => {
+      TestUtilsAct(() => {
         ReactDOM.render(
           <Example
             nestedObject={{
@@ -1221,7 +1226,7 @@ describe('InspectedElementContext', () => {
       });
     });
 
-    TestRenderer.act(() => {
+    TestRendererAct(() => {
       inspectedElement = null;
       jest.advanceTimersByTime(1000);
     });
@@ -1281,7 +1286,7 @@ describe('InspectedElementContext', () => {
     expect(inspectedElement).not.toBeNull();
     expect(inspectedElement).toMatchSnapshot('1: Initially inspect element');
 
-    TestUtils.act(() => {
+    TestUtilsAct(() => {
       ReactDOM.render(
         <Example
           nestedObject={{
@@ -1300,8 +1305,8 @@ describe('InspectedElementContext', () => {
 
     inspectedElement = null;
 
-    TestRenderer.act(() => {
-      TestUtils.act(() => {
+    TestRendererAct(() => {
+      TestUtilsAct(() => {
         getInspectedElementPath(id, ['props', 'nestedObject', 'a']);
         jest.runOnlyPendingTimers();
       });
diff --git a/packages/react-devtools-shared/src/__tests__/storeComponentFilters-test.js b/packages/react-devtools-shared/src/__tests__/storeComponentFilters-test.js
index 341e06b04d57e..1a5be03f09aad 100644
--- a/packages/react-devtools-shared/src/__tests__/storeComponentFilters-test.js
+++ b/packages/react-devtools-shared/src/__tests__/storeComponentFilters-test.js
@@ -20,7 +20,7 @@ describe('Store component filters', () => {
   let utils;
 
   const act = (callback: Function) => {
-    TestUtils.act(() => {
+    TestUtils.unstable_concurrentAct(() => {
       callback();
     });
     jest.runAllTimers(); // Flush Bridge operations
diff --git a/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js b/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js
index d6baddbe45c9e..5e783489bb932 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.js
@@ -28,7 +28,7 @@ describe('ReactDOMFiberAsync', () => {
     container = document.createElement('div');
     React = require('react');
     ReactDOM = require('react-dom');
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     Scheduler = require('scheduler');
 
     document.body.appendChild(container);
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationHooks-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationHooks-test.js
index a66a86866776f..6cb57a8560b73 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationHooks-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationHooks-test.js
@@ -17,6 +17,7 @@ let React;
 let ReactDOM;
 let ReactDOMServer;
 let ReactTestUtils;
+let act;
 let Scheduler;
 let useState;
 let useReducer;
@@ -43,6 +44,7 @@ function initModules() {
   ReactDOMServer = require('react-dom/server');
   ReactTestUtils = require('react-dom/test-utils');
   Scheduler = require('scheduler');
+  act = ReactTestUtils.unstable_concurrentAct;
   useState = React.useState;
   useReducer = React.useReducer;
   useEffect = React.useEffect;
@@ -1063,7 +1065,7 @@ describe('ReactDOMServerHooks', () => {
       expect(domNode.children.length).toEqual(1);
       expect(oldClientId).not.toBeNull();
 
-      await ReactTestUtils.act(async () => _setShowId(true));
+      await act(async () => _setShowId(true));
 
       expect(domNode.children.length).toEqual(2);
       expect(domNode.children[0].getAttribute('aria-labelledby')).toEqual(
@@ -1281,7 +1283,7 @@ describe('ReactDOMServerHooks', () => {
       const oldServerId = container.children[0].children[0].getAttribute('id');
       expect(oldServerId).not.toBeNull();
 
-      await ReactTestUtils.act(async () => {
+      await act(async () => {
         _setShowDiv(true);
       });
       expect(container.children[0].children.length).toEqual(2);
@@ -1322,7 +1324,7 @@ describe('ReactDOMServerHooks', () => {
       const oldServerId = container.children[0].children[0].getAttribute('id');
       expect(oldServerId).not.toBeNull();
 
-      await ReactTestUtils.act(async () => {
+      await act(async () => {
         _setShowDiv(true);
       });
       expect(container.children[0].children.length).toEqual(2);
@@ -1356,12 +1358,12 @@ describe('ReactDOMServerHooks', () => {
       document.body.append(container);
       container.innerHTML = ReactDOMServer.renderToString(<App />);
       const root = ReactDOM.unstable_createRoot(container, {hydrate: true});
-      ReactTestUtils.act(() => {
+      act(() => {
         root.render(<App />);
       });
       expect(Scheduler).toHaveYielded(['App', 'App']);
       // The ID goes from not being used to being added to the page
-      ReactTestUtils.act(() => {
+      act(() => {
         _setShow(true);
       });
       expect(Scheduler).toHaveYielded(['App', 'App']);
@@ -1391,7 +1393,7 @@ describe('ReactDOMServerHooks', () => {
       ReactDOM.hydrate(<App />, container);
       expect(Scheduler).toHaveYielded(['App', 'App']);
       // The ID goes from not being used to being added to the page
-      ReactTestUtils.act(() => {
+      act(() => {
         _setShow(true);
       });
       expect(Scheduler).toHaveYielded(['App']);
@@ -1418,12 +1420,12 @@ describe('ReactDOMServerHooks', () => {
       document.body.append(container);
       container.innerHTML = ReactDOMServer.renderToString(<App />);
       const root = ReactDOM.unstable_createRoot(container, {hydrate: true});
-      ReactTestUtils.act(() => {
+      act(() => {
         root.render(<App />);
       });
 
       // The ID goes from not being used to being added to the page
-      ReactTestUtils.act(() => {
+      act(() => {
         ReactDOM.flushSync(() => {
           _setShow(true);
         });
@@ -1518,7 +1520,7 @@ describe('ReactDOMServerHooks', () => {
       expect(child1Ref.current).toBe(null);
       expect(Scheduler).toHaveYielded([]);
 
-      ReactTestUtils.act(() => {
+      act(() => {
         _setShow(true);
 
         // State update should trigger the ID to update, which changes the props
@@ -1603,7 +1605,7 @@ describe('ReactDOMServerHooks', () => {
 
       suspend = true;
       const root = ReactDOM.unstable_createRoot(container, {hydrate: true});
-      await ReactTestUtils.act(async () => {
+      await act(async () => {
         root.render(<App />);
       });
       jest.runAllTimers();
@@ -1616,7 +1618,7 @@ describe('ReactDOMServerHooks', () => {
         container.children[0].children[0].getAttribute('id'),
       ).not.toBeNull();
 
-      await ReactTestUtils.act(async () => {
+      await act(async () => {
         suspend = false;
         resolve();
         await promise;
@@ -1703,7 +1705,7 @@ describe('ReactDOMServerHooks', () => {
 
       suspend = false;
       const root = ReactDOM.unstable_createRoot(container, {hydrate: true});
-      await ReactTestUtils.act(async () => {
+      await act(async () => {
         root.render(<App />);
       });
       jest.runAllTimers();
@@ -1968,7 +1970,7 @@ describe('ReactDOMServerHooks', () => {
       expect(Scheduler).toHaveYielded([]);
       expect(Scheduler).toFlushAndYield([]);
 
-      ReactTestUtils.act(() => {
+      act(() => {
         _setShow(false);
       });
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
index 1e6a912651832..9a897789b47ca 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerPartialHydration-test.internal.js
@@ -79,7 +79,7 @@ describe('ReactDOMServerPartialHydration', () => {
 
     React = require('react');
     ReactDOM = require('react-dom');
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     ReactDOMServer = require('react-dom/server');
     Scheduler = require('scheduler');
     Suspense = React.Suspense;
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerSelectiveHydration-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerSelectiveHydration-test.internal.js
index 3a948a0651b1d..6b543805ea102 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerSelectiveHydration-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerSelectiveHydration-test.internal.js
@@ -17,6 +17,7 @@ let ReactDOMServer;
 let ReactTestUtils;
 let Scheduler;
 let Suspense;
+let act;
 
 function dispatchMouseHoverEvent(to, from) {
   if (!to) {
@@ -101,6 +102,7 @@ describe('ReactDOMServerSelectiveHydration', () => {
     ReactDOM = require('react-dom');
     ReactDOMServer = require('react-dom/server');
     ReactTestUtils = require('react-dom/test-utils');
+    act = ReactTestUtils.unstable_concurrentAct;
     Scheduler = require('scheduler');
     Suspense = React.Suspense;
   });
@@ -880,7 +882,7 @@ describe('ReactDOMServerSelectiveHydration', () => {
     const spanC = container.getElementsByTagName('span')[4];
 
     const root = ReactDOM.createRoot(container, {hydrate: true});
-    ReactTestUtils.act(() => {
+    act(() => {
       root.render(<App a="A" />);
 
       // Hydrate the shell.
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerSuspense-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMServerSuspense-test.internal.js
index cc3b563d0ff43..6c48b36bd107d 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerSuspense-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerSuspense-test.internal.js
@@ -15,6 +15,7 @@ let React;
 let ReactDOM;
 let ReactDOMServer;
 let ReactTestUtils;
+let act;
 
 function initModules() {
   // Reset warning cache.
@@ -24,6 +25,7 @@ function initModules() {
   ReactDOM = require('react-dom');
   ReactDOMServer = require('react-dom/server');
   ReactTestUtils = require('react-dom/test-utils');
+  act = ReactTestUtils.unstable_concurrentAct;
 
   // Make them available to the helpers.
   return {
@@ -124,7 +126,7 @@ describe('ReactDOMServerSuspense', () => {
     expect(divB.tagName).toBe('DIV');
     expect(divB.textContent).toBe('B');
 
-    ReactTestUtils.act(() => {
+    act(() => {
       const root = ReactDOM.createBlockingRoot(parent, {hydrate: true});
       root.render(example);
     });
diff --git a/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js b/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
index 02da1e84b202c..44f6aeebe6711 100644
--- a/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMSuspensePlaceholder-test.js
@@ -28,7 +28,7 @@ describe('ReactDOMSuspensePlaceholder', () => {
     ReactCache = require('react-cache');
     ReactTestUtils = require('react-dom/test-utils');
     Scheduler = require('scheduler');
-    act = ReactTestUtils.act;
+    act = ReactTestUtils.unstable_concurrentAct;
     Suspense = React.Suspense;
     container = document.createElement('div');
     document.body.appendChild(container);
diff --git a/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js b/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
index 204c67ba52846..46ace25fd7a16 100644
--- a/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactErrorBoundaries-test.internal.js
@@ -44,7 +44,7 @@ describe('ReactErrorBoundaries', () => {
     ReactFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback = false;
     ReactDOM = require('react-dom');
     React = require('react');
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     Scheduler = require('scheduler');
 
     BrokenConstructor = class extends React.Component {
diff --git a/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js b/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
index 7b48d0118bebd..8be08aee8f404 100644
--- a/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
+++ b/packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js
@@ -14,6 +14,7 @@ let SchedulerTracing;
 let Scheduler;
 let act;
 let container;
+let log;
 
 jest.useRealTimers();
 
@@ -25,6 +26,12 @@ function sleep(period) {
   });
 }
 
+function flushLog() {
+  const prevLog = log;
+  log = [];
+  return prevLog;
+}
+
 describe('ReactTestUtils.act()', () => {
   // first we run all the tests with concurrent mode
   if (__EXPERIMENTAL__) {
@@ -33,18 +40,15 @@ describe('ReactTestUtils.act()', () => {
       concurrentRoot = ReactDOM.unstable_createRoot(dom);
       concurrentRoot.render(el);
     };
-
     const unmountConcurrent = _dom => {
       if (concurrentRoot !== null) {
         concurrentRoot.unmount();
         concurrentRoot = null;
       }
     };
-
     const rerenderConcurrent = el => {
       concurrentRoot.render(el);
     };
-
     runActTests(
       'concurrent mode',
       renderConcurrent,
@@ -79,18 +83,15 @@ describe('ReactTestUtils.act()', () => {
       blockingRoot = ReactDOM.unstable_createBlockingRoot(dom);
       blockingRoot.render(el);
     };
-
     const unmountBatched = dom => {
       if (blockingRoot !== null) {
         blockingRoot.unmount();
         blockingRoot = null;
       }
     };
-
     const rerenderBatched = el => {
       blockingRoot.render(el);
     };
-
     runActTests(
       'blocking mode',
       renderBatched,
@@ -125,6 +126,8 @@ describe('ReactTestUtils.act()', () => {
     });
 
     // @gate experimental
+    // @gate FIXME
+    // @gate __DEV__
     it('warns in blocking mode', () => {
       expect(() => {
         const root = ReactDOM.unstable_createBlockingRoot(
@@ -138,6 +141,8 @@ describe('ReactTestUtils.act()', () => {
     });
 
     // @gate experimental
+    // @gate FIXME
+    // @gate __DEV__
     it('warns in concurrent mode', () => {
       expect(() => {
         const root = ReactDOM.unstable_createRoot(
@@ -156,6 +161,7 @@ function runActTests(label, render, unmount, rerender) {
   describe(label, () => {
     beforeEach(() => {
       jest.resetModules();
+      jest.unmock('scheduler');
       React = require('react');
       ReactDOM = require('react-dom');
       ReactTestUtils = require('react-dom/test-utils');
@@ -164,6 +170,8 @@ function runActTests(label, render, unmount, rerender) {
       act = ReactTestUtils.act;
       container = document.createElement('div');
       document.body.appendChild(container);
+
+      log = [];
     });
 
     afterEach(() => {
@@ -172,10 +180,11 @@ function runActTests(label, render, unmount, rerender) {
     });
 
     describe('sync', () => {
+      // @gate __DEV__
       it('can use act to flush effects', () => {
         function App() {
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue(100);
+            log.push(100);
           });
           return null;
         }
@@ -184,14 +193,15 @@ function runActTests(label, render, unmount, rerender) {
           render(<App />, container);
         });
 
-        expect(Scheduler).toHaveYielded([100]);
+        expect(flushLog()).toEqual([100]);
       });
 
+      // @gate __DEV__
       it('flushes effects on every call', () => {
         function App() {
           const [ctr, setCtr] = React.useState(0);
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue(ctr);
+            log.push(ctr);
           });
           return (
             <button id="button" onClick={() => setCtr(x => x + 1)}>
@@ -203,7 +213,7 @@ function runActTests(label, render, unmount, rerender) {
         act(() => {
           render(<App />, container);
         });
-        expect(Scheduler).toHaveYielded([0]);
+        expect(flushLog()).toEqual([0]);
         const button = container.querySelector('#button');
         function click() {
           button.dispatchEvent(new MouseEvent('click', {bubbles: true}));
@@ -215,14 +225,15 @@ function runActTests(label, render, unmount, rerender) {
           click();
         });
         // it consolidates the 3 updates, then fires the effect
-        expect(Scheduler).toHaveYielded([3]);
+        expect(flushLog()).toEqual([3]);
         act(click);
-        expect(Scheduler).toHaveYielded([4]);
+        expect(flushLog()).toEqual([4]);
         act(click);
-        expect(Scheduler).toHaveYielded([5]);
+        expect(flushLog()).toEqual([5]);
         expect(button.innerHTML).toBe('5');
       });
 
+      // @gate __DEV__
       it("should keep flushing effects until they're done", () => {
         function App() {
           const [ctr, setCtr] = React.useState(0);
@@ -241,10 +252,11 @@ function runActTests(label, render, unmount, rerender) {
         expect(container.innerHTML).toBe('5');
       });
 
+      // @gate __DEV__
       it('should flush effects only on exiting the outermost act', () => {
         function App() {
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue(0);
+            log.push(0);
           });
           return null;
         }
@@ -255,12 +267,13 @@ function runActTests(label, render, unmount, rerender) {
           });
           // the effect wouldn't have yielded yet because
           // we're still inside an act() scope
-          expect(Scheduler).toHaveYielded([]);
+          expect(flushLog()).toEqual([]);
         });
         // but after exiting the last one, effects get flushed
-        expect(Scheduler).toHaveYielded([0]);
+        expect(flushLog()).toEqual([0]);
       });
 
+      // @gate __DEV__
       it('warns if a setState is called outside of act(...)', () => {
         let setValue = null;
         function App() {
@@ -287,6 +300,7 @@ function runActTests(label, render, unmount, rerender) {
           jest.useRealTimers();
         });
 
+        // @gate __DEV__
         it('lets a ticker update', () => {
           function App() {
             const [toggle, setToggle] = React.useState(0);
@@ -309,6 +323,7 @@ function runActTests(label, render, unmount, rerender) {
           expect(container.innerHTML).toBe('1');
         });
 
+        // @gate __DEV__
         it('can use the async version to catch microtasks', async () => {
           function App() {
             const [toggle, setToggle] = React.useState(0);
@@ -331,6 +346,7 @@ function runActTests(label, render, unmount, rerender) {
           expect(container.innerHTML).toBe('1');
         });
 
+        // @gate __DEV__
         it('can handle cascading promises with fake timers', async () => {
           // this component triggers an effect, that waits a tick,
           // then sets state. repeats this 5 times.
@@ -354,6 +370,7 @@ function runActTests(label, render, unmount, rerender) {
           expect(container.innerHTML).toBe('5');
         });
 
+        // @gate __DEV__
         it('flushes immediate re-renders with act', () => {
           function App() {
             const [ctr, setCtr] = React.useState(0);
@@ -383,6 +400,7 @@ function runActTests(label, render, unmount, rerender) {
         });
       });
 
+      // @gate __DEV__
       it('warns if you return a value inside act', () => {
         expect(() => act(() => null)).toErrorDev(
           [
@@ -398,6 +416,7 @@ function runActTests(label, render, unmount, rerender) {
         );
       });
 
+      // @gate __DEV__
       it('warns if you try to await a sync .act call', () => {
         expect(() => act(() => {}).then(() => {})).toErrorDev(
           [
@@ -409,6 +428,7 @@ function runActTests(label, render, unmount, rerender) {
     });
 
     describe('asynchronous tests', () => {
+      // @gate __DEV__
       it('works with timeouts', async () => {
         function App() {
           const [ctr, setCtr] = React.useState(0);
@@ -426,13 +446,14 @@ function runActTests(label, render, unmount, rerender) {
 
         await act(async () => {
           render(<App />, container);
-          // flush a little to start the timer
-          expect(Scheduler).toFlushAndYield([]);
+        });
+        await act(async () => {
           await sleep(100);
         });
         expect(container.innerHTML).toBe('1');
       });
 
+      // @gate __DEV__
       it('flushes microtasks before exiting', async () => {
         function App() {
           const [ctr, setCtr] = React.useState(0);
@@ -455,19 +476,19 @@ function runActTests(label, render, unmount, rerender) {
         expect(container.innerHTML).toEqual('1');
       });
 
+      // @gate __DEV__
       it('warns if you do not await an act call', async () => {
         spyOnDevAndProd(console, 'error');
         act(async () => {});
         // it's annoying that we have to wait a tick before this warning comes in
         await sleep(0);
-        if (__DEV__) {
-          expect(console.error.calls.count()).toEqual(1);
-          expect(console.error.calls.argsFor(0)[0]).toMatch(
-            'You called act(async () => ...) without await.',
-          );
-        }
+        expect(console.error.calls.count()).toEqual(1);
+        expect(console.error.calls.argsFor(0)[0]).toMatch(
+          'You called act(async () => ...) without await.',
+        );
       });
 
+      // @gate __DEV__
       it('warns if you try to interleave multiple act calls', async () => {
         spyOnDevAndProd(console, 'error');
         // let's try to cheat and spin off a 'thread' with an act call
@@ -482,11 +503,13 @@ function runActTests(label, render, unmount, rerender) {
         });
 
         await sleep(150);
-        if (__DEV__) {
-          expect(console.error).toHaveBeenCalledTimes(1);
-        }
+        expect(console.error).toHaveBeenCalledTimes(1);
+        expect(console.error.calls.argsFor(0)[0]).toMatch(
+          'You seem to have overlapping act() calls',
+        );
       });
 
+      // @gate __DEV__
       it('async commits and effects are guaranteed to be flushed', async () => {
         function App() {
           const [state, setState] = React.useState(0);
@@ -498,7 +521,7 @@ function runActTests(label, render, unmount, rerender) {
             something();
           }, []);
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue(state);
+            log.push(state);
           });
           return state;
         }
@@ -508,10 +531,11 @@ function runActTests(label, render, unmount, rerender) {
         });
         // exiting act() drains effects and microtasks
 
-        expect(Scheduler).toHaveYielded([0, 1]);
+        expect(flushLog()).toEqual([0, 1]);
         expect(container.innerHTML).toBe('1');
       });
 
+      // @gate __DEV__
       it('can handle cascading promises', async () => {
         // this component triggers an effect, that waits a tick,
         // then sets state. repeats this 5 times.
@@ -522,7 +546,7 @@ function runActTests(label, render, unmount, rerender) {
             setState(x => x + 1);
           }
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue(state);
+            log.push(state);
             ticker();
           }, [Math.min(state, 4)]);
           return state;
@@ -532,13 +556,16 @@ function runActTests(label, render, unmount, rerender) {
           render(<App />, container);
         });
         // all 5 ticks present and accounted for
-        expect(Scheduler).toHaveYielded([0, 1, 2, 3, 4]);
+        expect(flushLog()).toEqual([0, 1, 2, 3, 4]);
         expect(container.innerHTML).toBe('5');
       });
     });
 
     describe('interaction tracing', () => {
+      // TODO: Remove this __DEV__ check. Will do in a later commit, since it
+      // affects whitespace.
       if (__DEV__) {
+        // @gate __DEV__
         it('should correctly trace interactions for sync roots', () => {
           let expectedInteraction;
 
@@ -619,6 +646,7 @@ function runActTests(label, render, unmount, rerender) {
     });
 
     describe('error propagation', () => {
+      // @gate __DEV__
       it('propagates errors - sync', () => {
         let err;
         try {
@@ -633,6 +661,7 @@ function runActTests(label, render, unmount, rerender) {
         }
       });
 
+      // @gate __DEV__
       it('should propagate errors from effects - sync', () => {
         function App() {
           React.useEffect(() => {
@@ -654,6 +683,7 @@ function runActTests(label, render, unmount, rerender) {
         }
       });
 
+      // @gate __DEV__
       it('propagates errors - async', async () => {
         let err;
         try {
@@ -669,10 +699,11 @@ function runActTests(label, render, unmount, rerender) {
         }
       });
 
+      // @gate __DEV__
       it('should cleanup after errors - sync', () => {
         function App() {
           React.useEffect(() => {
-            Scheduler.unstable_yieldValue('oh yes');
+            log.push('oh yes');
           });
           return null;
         }
@@ -690,15 +721,16 @@ function runActTests(label, render, unmount, rerender) {
           act(() => {
             render(<App />, container);
           });
-          expect(Scheduler).toHaveYielded(['oh yes']);
+          expect(flushLog()).toEqual(['oh yes']);
         }
       });
 
+      // @gate __DEV__
       it('should cleanup after errors - async', async () => {
         function App() {
           async function somethingAsync() {
             await null;
-            Scheduler.unstable_yieldValue('oh yes');
+            log.push('oh yes');
           }
           React.useEffect(() => {
             somethingAsync();
@@ -720,14 +752,15 @@ function runActTests(label, render, unmount, rerender) {
           await act(async () => {
             render(<App />, container);
           });
-          expect(Scheduler).toHaveYielded(['oh yes']);
+          expect(flushLog()).toEqual(['oh yes']);
         }
       });
     });
 
     describe('suspense', () => {
-      if (__DEV__ && __EXPERIMENTAL__) {
+      if (__EXPERIMENTAL__) {
         // todo - remove __DEV__ check once we start using testing builds
+        // @gate __DEV__
         it('triggers fallbacks if available', async () => {
           let resolved = false;
           let resolve;
@@ -803,19 +836,16 @@ function runActTests(label, render, unmount, rerender) {
       }
     });
     describe('warn in prod mode', () => {
+      // @gate !__DEV__
       it('warns if you try to use act() in prod mode', () => {
         const spy = spyOnDevAndProd(console, 'error');
 
         act(() => {});
 
-        if (!__DEV__) {
-          expect(console.error).toHaveBeenCalledTimes(1);
-          expect(console.error.calls.argsFor(0)[0]).toContain(
-            'act(...) is not supported in production builds of React',
-          );
-        } else {
-          expect(console.error).toHaveBeenCalledTimes(0);
-        }
+        expect(console.error).toHaveBeenCalledTimes(1);
+        expect(console.error.calls.argsFor(0)[0]).toContain(
+          'act(...) is not supported in production builds of React',
+        );
 
         spy.calls.reset();
         // does not warn twice
diff --git a/packages/react-dom/src/__tests__/ReactTestUtilsActUnmockedScheduler-test.js b/packages/react-dom/src/__tests__/ReactTestUtilsActUnmockedScheduler-test.js
index f7145f657c72d..e1ff6f8700195 100644
--- a/packages/react-dom/src/__tests__/ReactTestUtilsActUnmockedScheduler-test.js
+++ b/packages/react-dom/src/__tests__/ReactTestUtilsActUnmockedScheduler-test.js
@@ -47,6 +47,7 @@ afterEach(() => {
   document.body.removeChild(container);
 });
 
+// @gate __DEV__
 it('can use act to flush effects', () => {
   function App() {
     React.useEffect(() => {
@@ -62,6 +63,7 @@ it('can use act to flush effects', () => {
   expect(clearYields()).toEqual([100]);
 });
 
+// @gate __DEV__
 it('flushes effects on every call', () => {
   function App() {
     const [ctr, setCtr] = React.useState(0);
@@ -100,6 +102,7 @@ it('flushes effects on every call', () => {
   expect(button.innerHTML).toEqual('5');
 });
 
+// @gate __DEV__
 it("should keep flushing effects until they're done", () => {
   function App() {
     const [ctr, setCtr] = React.useState(0);
@@ -118,6 +121,7 @@ it("should keep flushing effects until they're done", () => {
   expect(container.innerHTML).toEqual('5');
 });
 
+// @gate __DEV__
 it('should flush effects only on exiting the outermost act', () => {
   function App() {
     React.useEffect(() => {
@@ -138,6 +142,7 @@ it('should flush effects only on exiting the outermost act', () => {
   expect(clearYields()).toEqual([0]);
 });
 
+// @gate __DEV__
 it('can handle cascading promises', async () => {
   // this component triggers an effect, that waits a tick,
   // then sets state. repeats this 5 times.
diff --git a/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.internal.js b/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.internal.js
deleted file mode 100644
index 501b01336b1b3..0000000000000
--- a/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.internal.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @emails react-core
- */
-
-let React;
-let ReactDOM;
-let ReactFeatureFlags;
-
-function App() {
-  return null;
-}
-
-beforeEach(() => {
-  jest.resetModules();
-  jest.unmock('scheduler');
-  React = require('react');
-  ReactDOM = require('react-dom');
-  ReactFeatureFlags = require('shared/ReactFeatureFlags');
-  ReactFeatureFlags.warnAboutUnmockedScheduler = true;
-});
-
-afterEach(() => {
-  ReactFeatureFlags.warnAboutUnmockedScheduler = false;
-});
-
-it('should warn in legacy mode', () => {
-  expect(() => {
-    ReactDOM.render(<App />, document.createElement('div'));
-  }).toErrorDev(
-    ['Starting from React v18, the "scheduler" module will need to be mocked'],
-    {withoutStack: true},
-  );
-  // does not warn twice
-  expect(() => {
-    ReactDOM.render(<App />, document.createElement('div'));
-  }).toErrorDev([]);
-});
-
-it('does not warn if Scheduler is mocked', () => {
-  jest.resetModules();
-  jest.mock('scheduler', () => require('scheduler/unstable_mock'));
-  React = require('react');
-  ReactDOM = require('react-dom');
-  ReactFeatureFlags = require('shared/ReactFeatureFlags');
-  ReactFeatureFlags.warnAboutUnmockedScheduler = true;
-
-  // This should not warn
-  expect(() => {
-    ReactDOM.render(<App />, document.createElement('div'));
-  }).toErrorDev([]);
-});
diff --git a/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.js b/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.js
index 57fc7fdcdc403..b6d39e4d12b61 100644
--- a/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.js
+++ b/packages/react-dom/src/__tests__/ReactUnmockedSchedulerWarning-test.js
@@ -7,56 +7,142 @@
  * @emails react-core
  */
 
-let React;
-let ReactDOM;
-
-function App() {
-  return null;
-}
-
 beforeEach(() => {
   jest.resetModules();
-  jest.unmock('scheduler');
-  React = require('react');
-  ReactDOM = require('react-dom');
+
+  // Unmock the Scheduler, which is mocked by default in our test setup
+  jest.mock('scheduler', () => require.requireActual('scheduler'));
+  jest.mock('scheduler/src/SchedulerHostConfig', () =>
+    require.requireActual('scheduler/src/forks/SchedulerHostConfig.default.js'),
+  );
+});
+
+// @gate __DEV__
+it('public implementation of `act` works without mocking scheduler (DOM)', async () => {
+  const React = require('react');
+  const ReactDOM = require('react-dom');
+  const TestUtils = require('react-dom/test-utils');
+
+  const log = [];
+
+  function App() {
+    React.useEffect(() => {
+      log.push('Did mount');
+    }, []);
+    return 'App';
+  }
+
+  const container = document.createElement('div');
+  await TestUtils.act(async () => {
+    ReactDOM.render(<App />, container);
+  });
+  expect(container.textContent).toEqual('App');
+  expect(log).toEqual(['Did mount']);
 });
 
-it('does not warn when rendering in legacy mode', () => {
-  expect(() => {
-    ReactDOM.render(<App />, document.createElement('div'));
-  }).toErrorDev([]);
+it('internal implementation of `act` throws if Scheduler is not mocked (DOM)', async () => {
+  const React = require('react');
+  const ReactDOM = require('react-dom');
+  const TestUtils = require('react-dom/test-utils');
+
+  const log = [];
+
+  function App() {
+    React.useEffect(() => {
+      log.push('Did mount');
+    }, []);
+    return 'App';
+  }
+
+  const container = document.createElement('div');
+  let error = null;
+  try {
+    await TestUtils.unstable_concurrentAct(async () => {
+      ReactDOM.render(<App />, container);
+    });
+  } catch (e) {
+    error = e;
+  }
+  expect(error).not.toBe(null);
+  expect(error.message).toEqual(
+    'This version of `act` requires a special mock build of Scheduler.',
+  );
 });
 
-// @gate experimental
-it('should warn when rendering in concurrent mode', () => {
-  expect(() => {
-    ReactDOM.unstable_createRoot(document.createElement('div')).render(<App />);
-  }).toErrorDev(
-    'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' +
-      'to guarantee consistent behaviour across tests and browsers.',
-    {withoutStack: true},
+it('internal implementation of `act` throws if Scheduler is not mocked (noop)', async () => {
+  const React = require('react');
+  const ReactNoop = require('react-noop-renderer');
+
+  const log = [];
+
+  function App() {
+    React.useEffect(() => {
+      log.push('Did mount');
+    }, []);
+    return 'App';
+  }
+
+  const root = ReactNoop.createRoot();
+  let error = null;
+  try {
+    await ReactNoop.act(async () => {
+      root.render(<App />);
+    });
+  } catch (e) {
+    error = e;
+  }
+  expect(error).not.toBe(null);
+  expect(error.message).toEqual(
+    'This version of `act` requires a special mock build of Scheduler.',
   );
-  // does not warn twice
-  expect(() => {
-    ReactDOM.unstable_createRoot(document.createElement('div')).render(<App />);
-  }).toErrorDev([]);
 });
 
-// @gate experimental
-it('should warn when rendering in blocking mode', () => {
-  expect(() => {
-    ReactDOM.unstable_createBlockingRoot(document.createElement('div')).render(
-      <App />,
-    );
-  }).toErrorDev(
-    'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' +
-      'to guarantee consistent behaviour across tests and browsers.',
-    {withoutStack: true},
+// @gate __DEV__
+it('public implementation of `act` works without mocking scheduler (test renderer)', async () => {
+  const React = require('react');
+  const ReactTestRenderer = require('react-test-renderer');
+
+  const log = [];
+
+  function App() {
+    React.useEffect(() => {
+      log.push('Did mount');
+    }, []);
+    return 'App';
+  }
+
+  const root = ReactTestRenderer.create(null);
+  await ReactTestRenderer.act(async () => {
+    root.update(<App />);
+  });
+  expect(root.toJSON()).toEqual('App');
+  expect(log).toEqual(['Did mount']);
+});
+
+it('internal implementation of `act` throws if Scheduler is not mocked (test renderer)', async () => {
+  const React = require('react');
+  const ReactTestRenderer = require('react-test-renderer');
+
+  const log = [];
+
+  function App() {
+    React.useEffect(() => {
+      log.push('Did mount');
+    }, []);
+    return 'App';
+  }
+
+  const root = ReactTestRenderer.create(null);
+  let error = null;
+  try {
+    await ReactTestRenderer.unstable_concurrentAct(async () => {
+      root.update(<App />);
+    });
+  } catch (e) {
+    error = e;
+  }
+  expect(error).not.toBe(null);
+  expect(error.message).toEqual(
+    'This version of `act` requires a special mock build of Scheduler.',
   );
-  // does not warn twice
-  expect(() => {
-    ReactDOM.unstable_createBlockingRoot(document.createElement('div')).render(
-      <App />,
-    );
-  }).toErrorDev([]);
 });
diff --git a/packages/react-dom/src/__tests__/ReactUpdates-test.js b/packages/react-dom/src/__tests__/ReactUpdates-test.js
index 2bf80a2090c47..f876158b6718e 100644
--- a/packages/react-dom/src/__tests__/ReactUpdates-test.js
+++ b/packages/react-dom/src/__tests__/ReactUpdates-test.js
@@ -21,7 +21,7 @@ describe('ReactUpdates', () => {
     React = require('react');
     ReactDOM = require('react-dom');
     ReactTestUtils = require('react-dom/test-utils');
-    act = ReactTestUtils.act;
+    act = ReactTestUtils.unstable_concurrentAct;
     Scheduler = require('scheduler');
   });
 
diff --git a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
index 33fd350cb6e6f..b81a749837802 100644
--- a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
+++ b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
@@ -49,11 +49,11 @@ module.exports = function(initModules) {
   function asyncReactDOMRender(reactElement, domElement, forceHydrate) {
     return new Promise(resolve => {
       if (forceHydrate) {
-        ReactTestUtils.act(() => {
+        ReactTestUtils.unstable_concurrentAct(() => {
           ReactDOM.hydrate(reactElement, domElement);
         });
       } else {
-        ReactTestUtils.act(() => {
+        ReactTestUtils.unstable_concurrentAct(() => {
           ReactDOM.render(reactElement, domElement);
         });
       }
diff --git a/packages/react-dom/src/client/ReactDOM.js b/packages/react-dom/src/client/ReactDOM.js
index 5daeef818161f..78c920ec44afb 100644
--- a/packages/react-dom/src/client/ReactDOM.js
+++ b/packages/react-dom/src/client/ReactDOM.js
@@ -37,6 +37,7 @@ import {
   attemptHydrationAtCurrentPriority,
   runWithPriority,
   getCurrentUpdateLanePriority,
+  act,
 } from 'react-reconciler/src/ReactFiberReconciler';
 import {createPortal as createPortalImpl} from 'react-reconciler/src/ReactPortal';
 import {canUseDOM} from 'shared/ExecutionEnvironment';
@@ -183,7 +184,9 @@ const Internals = {
     enqueueStateRestore,
     restoreStateIfNeeded,
     flushPassiveEffects,
+    // TODO: These are related to `act`, not events. Move to separate key?
     IsThisRendererActing,
+    act,
   ],
 };
 
diff --git a/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js b/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
index 96387223787a3..1a125dc260628 100644
--- a/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
@@ -17,6 +17,7 @@ let ReactDOM;
 let ReactDOMServer;
 let Scheduler;
 let ReactTestUtils;
+let act;
 
 function dispatchEvent(element, type) {
   const event = document.createEvent('Event');
@@ -1236,6 +1237,7 @@ describe('DOMPluginEventSystem', () => {
             Scheduler = require('scheduler');
             ReactDOMServer = require('react-dom/server');
             ReactTestUtils = require('react-dom/test-utils');
+            act = ReactTestUtils.unstable_concurrentAct;
           });
 
           // @gate experimental
@@ -2674,7 +2676,7 @@ describe('DOMPluginEventSystem', () => {
 
             const root = ReactDOM.createRoot(container2);
 
-            ReactTestUtils.act(() => {
+            act(() => {
               root.render(<Component />);
             });
             jest.runAllTimers();
@@ -2686,7 +2688,7 @@ describe('DOMPluginEventSystem', () => {
             expect(onAfterBlur).toHaveBeenCalledTimes(0);
 
             suspend = true;
-            ReactTestUtils.act(() => {
+            act(() => {
               root.render(<Component />);
             });
             jest.runAllTimers();
@@ -2746,7 +2748,7 @@ describe('DOMPluginEventSystem', () => {
             document.body.appendChild(container2);
 
             const root = ReactDOM.createRoot(container2);
-            ReactTestUtils.act(() => {
+            act(() => {
               root.render(<Component />);
             });
 
@@ -2757,7 +2759,7 @@ describe('DOMPluginEventSystem', () => {
 
             // Suspend. This hides the input node, causing it to lose focus.
             suspend = true;
-            ReactTestUtils.act(() => {
+            act(() => {
               root.render(<Component />);
             });
 
diff --git a/packages/react-dom/src/events/plugins/__tests__/ChangeEventPlugin-test.js b/packages/react-dom/src/events/plugins/__tests__/ChangeEventPlugin-test.js
index 9f80e7329c510..041231cac30cd 100644
--- a/packages/react-dom/src/events/plugins/__tests__/ChangeEventPlugin-test.js
+++ b/packages/react-dom/src/events/plugins/__tests__/ChangeEventPlugin-test.js
@@ -736,7 +736,7 @@ describe('ChangeEventPlugin', () => {
 
     // @gate experimental
     it('mouse enter/leave should be user-blocking but not discrete', async () => {
-      const {act} = TestUtils;
+      const {unstable_concurrentAct: act} = TestUtils;
       const {useState} = React;
 
       const root = ReactDOM.unstable_createRoot(container);
diff --git a/packages/react-dom/src/test-utils/ReactTestUtils.js b/packages/react-dom/src/test-utils/ReactTestUtils.js
index f281438e12288..ded943e77e07d 100644
--- a/packages/react-dom/src/test-utils/ReactTestUtils.js
+++ b/packages/react-dom/src/test-utils/ReactTestUtils.js
@@ -18,7 +18,7 @@ import {
 import {SyntheticEvent} from '../events/SyntheticEvent';
 import invariant from 'shared/invariant';
 import {ELEMENT_NODE} from '../shared/HTMLNodeType';
-import act from './ReactTestUtilsAct';
+import {unstable_concurrentAct} from './ReactTestUtilsAct';
 import {
   rethrowCaughtError,
   invokeGuardedCallbackAndCatchFirstError,
@@ -35,7 +35,9 @@ const [
   restoreStateIfNeeded,
   /* eslint-disable no-unused-vars */
   flushPassiveEffects,
+  // TODO: These are related to `act`, not events. Move to separate key?
   IsThisRendererActing,
+  act,
   /* eslint-enable no-unused-vars */
 ] = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
 
@@ -728,4 +730,5 @@ export {
   nativeTouchData,
   Simulate,
   act,
+  unstable_concurrentAct,
 };
diff --git a/packages/react-dom/src/test-utils/ReactTestUtilsAct.js b/packages/react-dom/src/test-utils/ReactTestUtilsAct.js
index 363826ca15342..7aad56ccecfb6 100644
--- a/packages/react-dom/src/test-utils/ReactTestUtilsAct.js
+++ b/packages/react-dom/src/test-utils/ReactTestUtilsAct.js
@@ -7,8 +7,6 @@
  * @flow
  */
 
-import type {Thenable} from 'shared/ReactTypes';
-
 import * as ReactDOM from 'react-dom';
 import ReactSharedInternals from 'shared/ReactSharedInternals';
 import enqueueTask from 'shared/enqueueTask';
@@ -22,8 +20,8 @@ const [
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  /* eslint-enable no-unused-vars */
   flushPassiveEffects,
+  /* eslint-enable no-unused-vars */
   IsThisRendererActing,
 ] = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
 
@@ -31,184 +29,115 @@ const batchedUpdates = ReactDOM.unstable_batchedUpdates;
 
 const {IsSomeRendererActing} = ReactSharedInternals;
 
-// this implementation should be exactly the same in
-// ReactTestUtilsAct.js, ReactTestRendererAct.js, createReactNoop.js
-
-const isSchedulerMocked =
-  typeof Scheduler.unstable_flushAllWithoutAsserting === 'function';
-const flushWork =
-  Scheduler.unstable_flushAllWithoutAsserting ||
-  function() {
-    let didFlushWork = false;
-    while (flushPassiveEffects()) {
-      didFlushWork = true;
-    }
-
-    return didFlushWork;
-  };
-
-function flushWorkAndMicroTasks(onDone: (err: ?Error) => void) {
-  try {
-    flushWork();
-    enqueueTask(() => {
-      if (flushWork()) {
-        flushWorkAndMicroTasks(onDone);
-      } else {
-        onDone();
-      }
-    });
-  } catch (err) {
-    onDone(err);
-  }
-}
-
-// we track the 'depth' of the act() calls with this counter,
-// so we can tell if any async act() calls try to run in parallel.
+// This version of `act` is only used by our tests. Unlike the public version
+// of `act`, it's designed to work identically in both production and
+// development. It may have slightly different behavior from the public
+// version, too, since our constraints in our test suite are not the same as
+// those of developers using React — we're testing React itself, as opposed to
+// building an app with React.
 
 let actingUpdatesScopeDepth = 0;
-let didWarnAboutUsingActInProd = false;
 
-function act(callback: () => Thenable<mixed>): Thenable<void> {
-  if (!__DEV__) {
-    if (didWarnAboutUsingActInProd === false) {
-      didWarnAboutUsingActInProd = true;
-      // eslint-disable-next-line react-internal/no-production-logging
-      console.error(
-        'act(...) is not supported in production builds of React, and might not behave as expected.',
-      );
-    }
+export function unstable_concurrentAct(scope: () => void) {
+  if (Scheduler.unstable_flushAllWithoutAsserting === undefined) {
+    throw Error(
+      'This version of `act` requires a special mock build of Scheduler.',
+    );
+  }
+  if (setTimeout._isMockFunction !== true) {
+    throw Error(
+      "This version of `act` requires Jest's timer mocks " +
+        '(i.e. jest.useFakeTimers).',
+    );
   }
-  const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
-  actingUpdatesScopeDepth++;
 
+  const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
   const previousIsSomeRendererActing = IsSomeRendererActing.current;
   const previousIsThisRendererActing = IsThisRendererActing.current;
   IsSomeRendererActing.current = true;
   IsThisRendererActing.current = true;
+  actingUpdatesScopeDepth++;
 
-  function onDone() {
+  const unwind = () => {
     actingUpdatesScopeDepth--;
     IsSomeRendererActing.current = previousIsSomeRendererActing;
     IsThisRendererActing.current = previousIsThisRendererActing;
+
     if (__DEV__) {
       if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
-        // if it's _less than_ previousActingUpdatesScopeDepth, then we can assume the 'other' one has warned
+        // if it's _less than_ previousActingUpdatesScopeDepth, then we can
+        // assume the 'other' one has warned
         console.error(
           'You seem to have overlapping act() calls, this is not supported. ' +
             'Be sure to await previous act() calls before making a new one. ',
         );
       }
     }
-  }
+  };
 
-  let result;
+  // TODO: This would be way simpler if 1) we required a promise to be
+  // returned and 2) we could use async/await. Since it's only our used in
+  // our test suite, we should be able to.
   try {
-    result = batchedUpdates(callback);
-  } catch (error) {
-    // on sync errors, we still want to 'cleanup' and decrement actingUpdatesScopeDepth
-    onDone();
-    throw error;
-  }
-
-  if (
-    result !== null &&
-    typeof result === 'object' &&
-    typeof result.then === 'function'
-  ) {
-    // setup a boolean that gets set to true only
-    // once this act() call is await-ed
-    let called = false;
-    if (__DEV__) {
-      if (typeof Promise !== 'undefined') {
-        //eslint-disable-next-line no-undef
-        Promise.resolve()
-          .then(() => {})
-          .then(() => {
-            if (called === false) {
-              console.error(
-                'You called act(async () => ...) without await. ' +
-                  'This could lead to unexpected testing behaviour, interleaving multiple act ' +
-                  'calls and mixing their scopes. You should - await act(async () => ...);',
+    const thenable = batchedUpdates(scope);
+    if (
+      typeof thenable === 'object' &&
+      thenable !== null &&
+      typeof thenable.then === 'function'
+    ) {
+      return {
+        then(resolve: () => void, reject: (error: mixed) => void) {
+          thenable.then(
+            () => {
+              flushActWork(
+                () => {
+                  unwind();
+                  resolve();
+                },
+                error => {
+                  unwind();
+                  reject(error);
+                },
               );
-            }
-          });
-      }
-    }
-
-    // in the async case, the returned thenable runs the callback, flushes
-    // effects and  microtasks in a loop until flushPassiveEffects() === false,
-    // and cleans up
-    return {
-      then(resolve, reject) {
-        called = true;
-        result.then(
-          () => {
-            if (
-              actingUpdatesScopeDepth > 1 ||
-              (isSchedulerMocked === true &&
-                previousIsSomeRendererActing === true)
-            ) {
-              onDone();
-              resolve();
-              return;
-            }
-            // we're about to exit the act() scope,
-            // now's the time to flush tasks/effects
-            flushWorkAndMicroTasks((err: ?Error) => {
-              onDone();
-              if (err) {
-                reject(err);
-              } else {
-                resolve();
-              }
-            });
-          },
-          err => {
-            onDone();
-            reject(err);
-          },
-        );
-      },
-    };
-  } else {
-    if (__DEV__) {
-      if (result !== undefined) {
-        console.error(
-          'The callback passed to act(...) function ' +
-            'must return undefined, or a Promise. You returned %s',
-          result,
-        );
+            },
+            error => {
+              unwind();
+              reject(error);
+            },
+          );
+        },
+      };
+    } else {
+      try {
+        // TODO: Let's not support non-async scopes at all in our tests. Need to
+        // migrate existing tests.
+        let didFlushWork;
+        do {
+          didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+        } while (didFlushWork);
+      } finally {
+        unwind();
       }
     }
+  } catch (error) {
+    unwind();
+    throw error;
+  }
+}
 
-    // flush effects until none remain, and cleanup
+function flushActWork(resolve, reject) {
+  // TODO: Run timers to flush short Suspense fallbacks
+  // jest.runOnlyPendingTimers();
+  enqueueTask(() => {
     try {
-      if (
-        actingUpdatesScopeDepth === 1 &&
-        (isSchedulerMocked === false || previousIsSomeRendererActing === false)
-      ) {
-        // we're about to exit the act() scope,
-        // now's the time to flush effects
-        flushWork();
+      const didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+      if (didFlushWork) {
+        flushActWork(resolve, reject);
+      } else {
+        resolve();
       }
-      onDone();
-    } catch (err) {
-      onDone();
-      throw err;
+    } catch (error) {
+      reject(error);
     }
-
-    // in the sync case, the returned thenable only warns *if* await-ed
-    return {
-      then(resolve) {
-        if (__DEV__) {
-          console.error(
-            'Do not await the result of calling act(...) with sync logic, it is not a Promise.',
-          );
-        }
-        resolve();
-      },
-    };
-  }
+  });
 }
-
-export default act;
diff --git a/packages/react-interactions/events/src/dom/create-event-handle/__tests__/useFocusWithin-test.internal.js b/packages/react-interactions/events/src/dom/create-event-handle/__tests__/useFocusWithin-test.internal.js
index 1b9c47224a97e..f1e8f57ac08d5 100644
--- a/packages/react-interactions/events/src/dom/create-event-handle/__tests__/useFocusWithin-test.internal.js
+++ b/packages/react-interactions/events/src/dom/create-event-handle/__tests__/useFocusWithin-test.internal.js
@@ -29,7 +29,7 @@ function initializeModules(hasPointerEvents) {
   ReactDOM = require('react-dom');
   ReactTestRenderer = require('react-test-renderer');
   Scheduler = require('scheduler');
-  act = ReactTestRenderer.act;
+  act = ReactTestRenderer.unstable_concurrentAct;
 
   // TODO: This import throws outside of experimental mode. Figure out better
   // strategy for gated imports.
diff --git a/packages/react-noop-renderer/src/createReactNoop.js b/packages/react-noop-renderer/src/createReactNoop.js
index cf9552fb2f9b9..6cbab7caa756b 100644
--- a/packages/react-noop-renderer/src/createReactNoop.js
+++ b/packages/react-noop-renderer/src/createReactNoop.js
@@ -27,6 +27,10 @@ import {
   LegacyRoot,
 } from 'react-reconciler/src/ReactRootTags';
 
+import ReactSharedInternals from 'shared/ReactSharedInternals';
+import enqueueTask from 'shared/enqueueTask';
+const {IsSomeRendererActing} = ReactSharedInternals;
+
 type Container = {
   rootID: string,
   children: Array<Instance | TextInstance>,
@@ -958,7 +962,8 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
 
     flushPassiveEffects: NoopRenderer.flushPassiveEffects,
 
-    act: NoopRenderer.act,
+    act: noopAct,
+    // act: NoopRenderer.act,
 
     // Logs the current state of the tree.
     dumpTree(rootID: string = DEFAULT_ROOT_ID) {
@@ -1073,6 +1078,120 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
     },
   };
 
+  // This version of `act` is only used by our tests. Unlike the public version
+  // of `act`, it's designed to work identically in both production and
+  // development. It may have slightly different behavior from the public
+  // version, too, since our constraints in our test suite are not the same as
+  // those of developers using React — we're testing React itself, as opposed to
+  // building an app with React.
+
+  const {batchedUpdates, IsThisRendererActing} = NoopRenderer;
+  let actingUpdatesScopeDepth = 0;
+
+  function noopAct(scope: () => void) {
+    if (Scheduler.unstable_flushAllWithoutAsserting === undefined) {
+      throw Error(
+        'This version of `act` requires a special mock build of Scheduler.',
+      );
+    }
+    if (setTimeout._isMockFunction !== true) {
+      throw Error(
+        "This version of `act` requires Jest's timer mocks " +
+          '(i.e. jest.useFakeTimers).',
+      );
+    }
+
+    const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
+    const previousIsSomeRendererActing = IsSomeRendererActing.current;
+    const previousIsThisRendererActing = IsThisRendererActing.current;
+    IsSomeRendererActing.current = true;
+    IsThisRendererActing.current = true;
+    actingUpdatesScopeDepth++;
+
+    const unwind = () => {
+      actingUpdatesScopeDepth--;
+      IsSomeRendererActing.current = previousIsSomeRendererActing;
+      IsThisRendererActing.current = previousIsThisRendererActing;
+
+      if (__DEV__) {
+        if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
+          // if it's _less than_ previousActingUpdatesScopeDepth, then we can
+          // assume the 'other' one has warned
+          console.error(
+            'You seem to have overlapping act() calls, this is not supported. ' +
+              'Be sure to await previous act() calls before making a new one. ',
+          );
+        }
+      }
+    };
+
+    // TODO: This would be way simpler if 1) we required a promise to be
+    // returned and 2) we could use async/await. Since it's only our used in
+    // our test suite, we should be able to.
+    try {
+      const thenable = batchedUpdates(scope);
+      if (
+        typeof thenable === 'object' &&
+        thenable !== null &&
+        typeof thenable.then === 'function'
+      ) {
+        return {
+          then(resolve, reject) {
+            thenable.then(
+              () => {
+                flushActWork(
+                  () => {
+                    unwind();
+                    resolve();
+                  },
+                  error => {
+                    unwind();
+                    reject(error);
+                  },
+                );
+              },
+              error => {
+                unwind();
+                reject(error);
+              },
+            );
+          },
+        };
+      } else {
+        try {
+          // TODO: Let's not support non-async scopes at all in our tests. Need to
+          // migrate existing tests.
+          let didFlushWork;
+          do {
+            didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+          } while (didFlushWork);
+        } finally {
+          unwind();
+        }
+      }
+    } catch (error) {
+      unwind();
+      throw error;
+    }
+  }
+
+  function flushActWork(resolve, reject) {
+    // TODO: Run timers to flush short Suspense fallbacks
+    // jest.runOnlyPendingTimers();
+    enqueueTask(() => {
+      try {
+        const didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+        if (didFlushWork) {
+          flushActWork(resolve, reject);
+        } else {
+          resolve();
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
   return ReactNoop;
 }
 
diff --git a/packages/react-reconciler/src/ReactFiberReconciler.new.js b/packages/react-reconciler/src/ReactFiberReconciler.new.js
index 6d514d2f2a369..b425aa5cbbee2 100644
--- a/packages/react-reconciler/src/ReactFiberReconciler.new.js
+++ b/packages/react-reconciler/src/ReactFiberReconciler.new.js
@@ -261,7 +261,6 @@ export function updateContainer(
   if (__DEV__) {
     // $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
     if ('undefined' !== typeof jest) {
-      warnIfUnmockedScheduler(current);
       warnIfNotScopedWithMatchingAct(current);
     }
   }
diff --git a/packages/react-reconciler/src/ReactFiberReconciler.old.js b/packages/react-reconciler/src/ReactFiberReconciler.old.js
index 5aa381ea4e5cd..0eb963f438f8f 100644
--- a/packages/react-reconciler/src/ReactFiberReconciler.old.js
+++ b/packages/react-reconciler/src/ReactFiberReconciler.old.js
@@ -61,7 +61,6 @@ import {
   flushDiscreteUpdates,
   flushPassiveEffects,
   warnIfNotScopedWithMatchingAct,
-  warnIfUnmockedScheduler,
   IsThisRendererActing,
   act,
 } from './ReactFiberWorkLoop.old';
@@ -261,7 +260,6 @@ export function updateContainer(
   if (__DEV__) {
     // $FlowExpectedError - jest isn't a global, and isn't recognized outside of tests
     if ('undefined' !== typeof jest) {
-      warnIfUnmockedScheduler(current);
       warnIfNotScopedWithMatchingAct(current);
     }
   }
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.new.js b/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
index 1e386c3309548..3179326dad56c 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
@@ -23,7 +23,8 @@ import {
   enableProfilerTimer,
   enableProfilerCommitHooks,
   enableSchedulerTracing,
-  warnAboutUnmockedScheduler,
+  // TODO: Remove this feature flag.
+  // warnAboutUnmockedScheduler,
   deferRenderPhaseUpdateToNextBatch,
   decoupleUpdatePriorityFromScheduler,
   enableDebugTracing,
@@ -76,9 +77,6 @@ import {
   markRenderStopped,
 } from './SchedulingProfiler';
 
-// The scheduler is imported here *only* to detect whether it's been mocked
-import * as Scheduler from 'scheduler';
-
 import {__interactionsRef, __subscriberRef} from 'scheduler/tracing';
 
 import {
@@ -716,7 +714,7 @@ function ensureRootIsScheduled(root: FiberRoot, currentTime: number) {
   }
 
   // Schedule a new callback.
-  let newCallbackNode;
+  let newCallbackNode = null;
   if (newCallbackPriority === SyncLanePriority) {
     // Special case: Sync React callbacks are scheduled on a special
     // internal queue
@@ -724,18 +722,30 @@ function ensureRootIsScheduled(root: FiberRoot, currentTime: number) {
       performSyncWorkOnRoot.bind(null, root),
     );
   } else if (newCallbackPriority === SyncBatchedLanePriority) {
-    newCallbackNode = scheduleCallback(
-      ImmediateSchedulerPriority,
-      performSyncWorkOnRoot.bind(null, root),
-    );
+    const callback = performSyncWorkOnRoot.bind(null, root);
+    if (__DEV__ && isInsideThisAct) {
+      if (actCallbackQueue === null) {
+        actCallbackQueue = [callback];
+      } else {
+        actCallbackQueue.push(callback);
+      }
+    } else {
+      newCallbackNode = scheduleCallback(ImmediateSchedulerPriority, callback);
+    }
   } else {
     const schedulerPriorityLevel = lanePriorityToSchedulerPriority(
       newCallbackPriority,
     );
-    newCallbackNode = scheduleCallback(
-      schedulerPriorityLevel,
-      performConcurrentWorkOnRoot.bind(null, root),
-    );
+    const callback = performConcurrentWorkOnRoot.bind(null, root);
+    if (__DEV__ && isInsideThisAct) {
+      if (actCallbackQueue === null) {
+        actCallbackQueue = [callback];
+      } else {
+        actCallbackQueue.push(callback);
+      }
+    } else {
+      newCallbackNode = scheduleCallback(schedulerPriorityLevel, callback);
+    }
   }
 
   root.callbackPriority = newCallbackPriority;
@@ -881,6 +891,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
       if (
         includesOnlyRetries(lanes) &&
         // do not delay if we're inside an act() scope
+        // TODO: Move this to directly around the scheduleTimeout call
         !shouldForceFlushFallbacksInDEV()
       ) {
         // This render only included retries, no updates. Throttle committing
@@ -929,6 +940,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         break;
       }
 
+      // TODO: Move this to directly around the scheduleTimeout call
       if (!shouldForceFlushFallbacksInDEV()) {
         // This is not a transition, but we did trigger an avoided state.
         // Schedule a placeholder to display after a short delay, using the Just
@@ -3412,46 +3424,6 @@ function warnIfNotCurrentlyActingUpdatesInDEV(fiber: Fiber): void {
 
 export const warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;
 
-// In tests, we want to enforce a mocked scheduler.
-let didWarnAboutUnmockedScheduler = false;
-// TODO Before we release concurrent mode, revisit this and decide whether a mocked
-// scheduler is the actual recommendation. The alternative could be a testing build,
-// a new lib, or whatever; we dunno just yet. This message is for early adopters
-// to get their tests right.
-
-export function warnIfUnmockedScheduler(fiber: Fiber) {
-  if (__DEV__) {
-    if (
-      didWarnAboutUnmockedScheduler === false &&
-      Scheduler.unstable_flushAllWithoutAsserting === undefined
-    ) {
-      if (fiber.mode & BlockingMode || fiber.mode & ConcurrentMode) {
-        didWarnAboutUnmockedScheduler = true;
-        console.error(
-          'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' +
-            'to guarantee consistent behaviour across tests and browsers. ' +
-            'For example, with jest: \n' +
-            // Break up requires to avoid accidentally parsing them as dependencies.
-            "jest.mock('scheduler', () => require" +
-            "('scheduler/unstable_mock'));\n\n" +
-            'For more info, visit https://reactjs.org/link/mock-scheduler',
-        );
-      } else if (warnAboutUnmockedScheduler === true) {
-        didWarnAboutUnmockedScheduler = true;
-        console.error(
-          'Starting from React v18, the "scheduler" module will need to be mocked ' +
-            'to guarantee consistent behaviour across tests and browsers. ' +
-            'For example, with jest: \n' +
-            // Break up requires to avoid accidentally parsing them as dependencies.
-            "jest.mock('scheduler', () => require" +
-            "('scheduler/unstable_mock'));\n\n" +
-            'For more info, visit https://reactjs.org/link/mock-scheduler',
-        );
-      }
-    }
-  }
-}
-
 function computeThreadID(root: FiberRoot, lane: Lane | Lanes) {
   // Interaction threads are unique per root and expiration time.
   // NOTE: Intentionally unsound cast. All that matters is that it's a number
@@ -3619,69 +3591,61 @@ function finishPendingInteractions(root, committedLanes) {
 // access to the same internals that we do here. Some trade offs in the
 // implementation no longer make sense.
 
-let isFlushingAct = false;
+let actCallbackQueue = null;
 let isInsideThisAct = false;
 
 // TODO: Yes, this is confusing. See above comment. We'll refactor it.
 function shouldForceFlushFallbacksInDEV() {
-  if (!__DEV__) {
-    // Never force flush in production. This function should get stripped out.
-    return false;
-  }
-  // `IsThisRendererActing.current` is used by ReactTestUtils version of `act`.
-  if (IsThisRendererActing.current) {
-    // `isInsideAct` is only used by the reconciler implementation of `act`.
-    // We don't want to flush suspense fallbacks until the end.
-    return !isInsideThisAct;
-  }
-  // Flush callbacks at the end.
-  return isFlushingAct;
+  // Never force flush in production. This function should get stripped out.
+  return __DEV__ && actingUpdatesScopeDepth > 0;
 }
 
-const flushMockScheduler = Scheduler.unstable_flushAllWithoutAsserting;
-const isSchedulerMocked = typeof flushMockScheduler === 'function';
-
-// Returns whether additional work was scheduled. Caller should keep flushing
-// until there's no work left.
-function flushActWork(): boolean {
-  if (flushMockScheduler !== undefined) {
-    const prevIsFlushing = isFlushingAct;
-    isFlushingAct = true;
+function flushActWorkAfterMicrotask(onDone: (err: ?Error) => void) {
+  enqueueTask(() => {
     try {
-      return flushMockScheduler();
-    } finally {
-      isFlushingAct = prevIsFlushing;
-    }
-  } else {
-    // No mock scheduler available. However, the only type of pending work is
-    // passive effects, which we control. So we can flush that.
-    const prevIsFlushing = isFlushingAct;
-    isFlushingAct = true;
-    try {
-      let didFlushWork = false;
-      while (flushPassiveEffects()) {
-        didFlushWork = true;
+      if (flushActWork()) {
+        flushActWorkAfterMicrotask(onDone);
+      } else {
+        onDone();
       }
-      return didFlushWork;
-    } finally {
-      isFlushingAct = prevIsFlushing;
+    } catch (error) {
+      onDone(error);
     }
+  });
+}
+
+// This is used when the `act` scope is not an async function.
+// TODO: Consider always requiring an async function.
+function flushActWork() {
+  if (flushActWorkImpl()) {
+    while (flushActWorkImpl()) {}
+    return true;
+  } else {
+    return false;
   }
 }
+function flushActWorkImpl() {
+  if (flushSyncCallbackQueue()) {
+    return true;
+  }
 
-function flushWorkAndMicroTasks(onDone: (err: ?Error) => void) {
   try {
-    flushActWork();
-    enqueueTask(() => {
-      if (flushActWork()) {
-        flushWorkAndMicroTasks(onDone);
-      } else {
-        onDone();
+    while (actCallbackQueue !== null) {
+      while (actCallbackQueue.length > 0) {
+        let callback = actCallbackQueue[0];
+        do {
+          callback = callback();
+        } while (callback !== null);
+        actCallbackQueue.shift();
       }
-    });
-  } catch (err) {
-    onDone(err);
+      actCallbackQueue = null;
+      return true;
+    }
+  } finally {
+    actCallbackQueue = null;
   }
+
+  return flushPassiveEffects();
 }
 
 // we track the 'depth' of the act() calls with this counter,
@@ -3694,6 +3658,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
   if (!__DEV__) {
     if (didWarnAboutUsingActInProd === false) {
       didWarnAboutUsingActInProd = true;
+      // TODO: Change this to an invariant before next major release
       // eslint-disable-next-line react-internal/no-production-logging
       console.error(
         'act(...) is not supported in production builds of React, and might not behave as expected.',
@@ -3771,8 +3736,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
           () => {
             if (
               actingUpdatesScopeDepth > 1 ||
-              (isSchedulerMocked === true &&
-                previousIsSomeRendererActing === true)
+              previousIsSomeRendererActing === true
             ) {
               onDone();
               resolve();
@@ -3780,7 +3744,8 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
             }
             // we're about to exit the act() scope,
             // now's the time to flush tasks/effects
-            flushWorkAndMicroTasks((err: ?Error) => {
+            flushActWork();
+            flushActWorkAfterMicrotask((err: ?Error) => {
               onDone();
               if (err) {
                 reject(err);
@@ -3811,7 +3776,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
     try {
       if (
         actingUpdatesScopeDepth === 1 &&
-        (isSchedulerMocked === false || previousIsSomeRendererActing === false)
+        previousIsSomeRendererActing === false
       ) {
         // we're about to exit the act() scope,
         // now's the time to flush effects
@@ -3827,6 +3792,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
     return {
       then(resolve) {
         if (__DEV__) {
+          // TODO: This warning needs to either not exist, or be rewritten.
           console.error(
             'Do not await the result of calling act(...) with sync logic, it is not a Promise.',
           );
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.old.js b/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
index e1cccf912c73d..d9d6cacc21c8b 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
@@ -23,7 +23,8 @@ import {
   enableProfilerTimer,
   enableProfilerCommitHooks,
   enableSchedulerTracing,
-  warnAboutUnmockedScheduler,
+  // TODO: Remove this feature flag.
+  // warnAboutUnmockedScheduler,
   deferRenderPhaseUpdateToNextBatch,
   decoupleUpdatePriorityFromScheduler,
   enableDebugTracing,
@@ -72,9 +73,6 @@ import {
   markRenderStopped,
 } from './SchedulingProfiler';
 
-// The scheduler is imported here *only* to detect whether it's been mocked
-import * as Scheduler from 'scheduler';
-
 import {__interactionsRef, __subscriberRef} from 'scheduler/tracing';
 
 import {
@@ -711,7 +709,7 @@ function ensureRootIsScheduled(root: FiberRoot, currentTime: number) {
   }
 
   // Schedule a new callback.
-  let newCallbackNode;
+  let newCallbackNode = null;
   if (newCallbackPriority === SyncLanePriority) {
     // Special case: Sync React callbacks are scheduled on a special
     // internal queue
@@ -719,18 +717,30 @@ function ensureRootIsScheduled(root: FiberRoot, currentTime: number) {
       performSyncWorkOnRoot.bind(null, root),
     );
   } else if (newCallbackPriority === SyncBatchedLanePriority) {
-    newCallbackNode = scheduleCallback(
-      ImmediateSchedulerPriority,
-      performSyncWorkOnRoot.bind(null, root),
-    );
+    const callback = performSyncWorkOnRoot.bind(null, root);
+    if (__DEV__ && isInsideThisAct) {
+      if (actCallbackQueue === null) {
+        actCallbackQueue = [callback];
+      } else {
+        actCallbackQueue.push(callback);
+      }
+    } else {
+      newCallbackNode = scheduleCallback(ImmediateSchedulerPriority, callback);
+    }
   } else {
     const schedulerPriorityLevel = lanePriorityToSchedulerPriority(
       newCallbackPriority,
     );
-    newCallbackNode = scheduleCallback(
-      schedulerPriorityLevel,
-      performConcurrentWorkOnRoot.bind(null, root),
-    );
+    const callback = performConcurrentWorkOnRoot.bind(null, root);
+    if (__DEV__ && isInsideThisAct) {
+      if (actCallbackQueue === null) {
+        actCallbackQueue = [callback];
+      } else {
+        actCallbackQueue.push(callback);
+      }
+    } else {
+      newCallbackNode = scheduleCallback(schedulerPriorityLevel, callback);
+    }
   }
 
   root.callbackPriority = newCallbackPriority;
@@ -876,6 +886,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
       if (
         includesOnlyRetries(lanes) &&
         // do not delay if we're inside an act() scope
+        // TODO: Move this to directly around the scheduleTimeout call
         !shouldForceFlushFallbacksInDEV()
       ) {
         // This render only included retries, no updates. Throttle committing
@@ -924,6 +935,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         break;
       }
 
+      // TODO: Move this to directly around the scheduleTimeout call
       if (!shouldForceFlushFallbacksInDEV()) {
         // This is not a transition, but we did trigger an avoided state.
         // Schedule a placeholder to display after a short delay, using the Just
@@ -3369,46 +3381,6 @@ function warnIfNotCurrentlyActingUpdatesInDEV(fiber: Fiber): void {
 
 export const warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;
 
-// In tests, we want to enforce a mocked scheduler.
-let didWarnAboutUnmockedScheduler = false;
-// TODO Before we release concurrent mode, revisit this and decide whether a mocked
-// scheduler is the actual recommendation. The alternative could be a testing build,
-// a new lib, or whatever; we dunno just yet. This message is for early adopters
-// to get their tests right.
-
-export function warnIfUnmockedScheduler(fiber: Fiber) {
-  if (__DEV__) {
-    if (
-      didWarnAboutUnmockedScheduler === false &&
-      Scheduler.unstable_flushAllWithoutAsserting === undefined
-    ) {
-      if (fiber.mode & BlockingMode || fiber.mode & ConcurrentMode) {
-        didWarnAboutUnmockedScheduler = true;
-        console.error(
-          'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' +
-            'to guarantee consistent behaviour across tests and browsers. ' +
-            'For example, with jest: \n' +
-            // Break up requires to avoid accidentally parsing them as dependencies.
-            "jest.mock('scheduler', () => require" +
-            "('scheduler/unstable_mock'));\n\n" +
-            'For more info, visit https://reactjs.org/link/mock-scheduler',
-        );
-      } else if (warnAboutUnmockedScheduler === true) {
-        didWarnAboutUnmockedScheduler = true;
-        console.error(
-          'Starting from React v18, the "scheduler" module will need to be mocked ' +
-            'to guarantee consistent behaviour across tests and browsers. ' +
-            'For example, with jest: \n' +
-            // Break up requires to avoid accidentally parsing them as dependencies.
-            "jest.mock('scheduler', () => require" +
-            "('scheduler/unstable_mock'));\n\n" +
-            'For more info, visit https://reactjs.org/link/mock-scheduler',
-        );
-      }
-    }
-  }
-}
-
 function computeThreadID(root: FiberRoot, lane: Lane | Lanes) {
   // Interaction threads are unique per root and expiration time.
   // NOTE: Intentionally unsound cast. All that matters is that it's a number
@@ -3576,69 +3548,61 @@ function finishPendingInteractions(root, committedLanes) {
 // access to the same internals that we do here. Some trade offs in the
 // implementation no longer make sense.
 
-let isFlushingAct = false;
+let actCallbackQueue = null;
 let isInsideThisAct = false;
 
 // TODO: Yes, this is confusing. See above comment. We'll refactor it.
 function shouldForceFlushFallbacksInDEV() {
-  if (!__DEV__) {
-    // Never force flush in production. This function should get stripped out.
-    return false;
-  }
-  // `IsThisRendererActing.current` is used by ReactTestUtils version of `act`.
-  if (IsThisRendererActing.current) {
-    // `isInsideAct` is only used by the reconciler implementation of `act`.
-    // We don't want to flush suspense fallbacks until the end.
-    return !isInsideThisAct;
-  }
-  // Flush callbacks at the end.
-  return isFlushingAct;
+  // Never force flush in production. This function should get stripped out.
+  return __DEV__ && actingUpdatesScopeDepth > 0;
 }
 
-const flushMockScheduler = Scheduler.unstable_flushAllWithoutAsserting;
-const isSchedulerMocked = typeof flushMockScheduler === 'function';
-
-// Returns whether additional work was scheduled. Caller should keep flushing
-// until there's no work left.
-function flushActWork(): boolean {
-  if (flushMockScheduler !== undefined) {
-    const prevIsFlushing = isFlushingAct;
-    isFlushingAct = true;
+function flushActWorkAfterMicrotask(onDone: (err: ?Error) => void) {
+  enqueueTask(() => {
     try {
-      return flushMockScheduler();
-    } finally {
-      isFlushingAct = prevIsFlushing;
-    }
-  } else {
-    // No mock scheduler available. However, the only type of pending work is
-    // passive effects, which we control. So we can flush that.
-    const prevIsFlushing = isFlushingAct;
-    isFlushingAct = true;
-    try {
-      let didFlushWork = false;
-      while (flushPassiveEffects()) {
-        didFlushWork = true;
+      if (flushActWork()) {
+        flushActWorkAfterMicrotask(onDone);
+      } else {
+        onDone();
       }
-      return didFlushWork;
-    } finally {
-      isFlushingAct = prevIsFlushing;
+    } catch (error) {
+      onDone(error);
     }
+  });
+}
+
+// This is used when the `act` scope is not an async function.
+// TODO: Consider always requiring an async function.
+function flushActWork() {
+  if (flushActWorkImpl()) {
+    while (flushActWorkImpl()) {}
+    return true;
+  } else {
+    return false;
   }
 }
+function flushActWorkImpl() {
+  if (flushSyncCallbackQueue()) {
+    return true;
+  }
 
-function flushWorkAndMicroTasks(onDone: (err: ?Error) => void) {
   try {
-    flushActWork();
-    enqueueTask(() => {
-      if (flushActWork()) {
-        flushWorkAndMicroTasks(onDone);
-      } else {
-        onDone();
+    while (actCallbackQueue !== null) {
+      while (actCallbackQueue.length > 0) {
+        let callback = actCallbackQueue[0];
+        do {
+          callback = callback();
+        } while (callback !== null);
+        actCallbackQueue.shift();
       }
-    });
-  } catch (err) {
-    onDone(err);
+      actCallbackQueue = null;
+      return true;
+    }
+  } finally {
+    actCallbackQueue = null;
   }
+
+  return flushPassiveEffects();
 }
 
 // we track the 'depth' of the act() calls with this counter,
@@ -3651,6 +3615,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
   if (!__DEV__) {
     if (didWarnAboutUsingActInProd === false) {
       didWarnAboutUsingActInProd = true;
+      // TODO: Change this to an invariant before next major release
       // eslint-disable-next-line react-internal/no-production-logging
       console.error(
         'act(...) is not supported in production builds of React, and might not behave as expected.',
@@ -3728,8 +3693,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
           () => {
             if (
               actingUpdatesScopeDepth > 1 ||
-              (isSchedulerMocked === true &&
-                previousIsSomeRendererActing === true)
+              previousIsSomeRendererActing === true
             ) {
               onDone();
               resolve();
@@ -3737,7 +3701,8 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
             }
             // we're about to exit the act() scope,
             // now's the time to flush tasks/effects
-            flushWorkAndMicroTasks((err: ?Error) => {
+            flushActWork();
+            flushActWorkAfterMicrotask((err: ?Error) => {
               onDone();
               if (err) {
                 reject(err);
@@ -3768,7 +3733,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
     try {
       if (
         actingUpdatesScopeDepth === 1 &&
-        (isSchedulerMocked === false || previousIsSomeRendererActing === false)
+        previousIsSomeRendererActing === false
       ) {
         // we're about to exit the act() scope,
         // now's the time to flush effects
@@ -3784,6 +3749,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
     return {
       then(resolve) {
         if (__DEV__) {
+          // TODO: This warning needs to either not exist, or be rewritten.
           console.error(
             'Do not await the result of calling act(...) with sync logic, it is not a Promise.',
           );
diff --git a/packages/react-reconciler/src/SchedulerWithReactIntegration.new.js b/packages/react-reconciler/src/SchedulerWithReactIntegration.new.js
index 606a90252077e..f73ae2f8998f4 100644
--- a/packages/react-reconciler/src/SchedulerWithReactIntegration.new.js
+++ b/packages/react-reconciler/src/SchedulerWithReactIntegration.new.js
@@ -165,13 +165,13 @@ export function cancelCallback(callbackNode: mixed) {
   }
 }
 
-export function flushSyncCallbackQueue() {
+export function flushSyncCallbackQueue(): boolean {
   if (immediateQueueCallbackNode !== null) {
     const node = immediateQueueCallbackNode;
     immediateQueueCallbackNode = null;
     Scheduler_cancelCallback(node);
   }
-  flushSyncCallbackQueueImpl();
+  return flushSyncCallbackQueueImpl();
 }
 
 function flushSyncCallbackQueueImpl() {
@@ -237,5 +237,8 @@ function flushSyncCallbackQueueImpl() {
         isFlushingSyncQueue = false;
       }
     }
+    return true;
+  } else {
+    return false;
   }
 }
diff --git a/packages/react-reconciler/src/__tests__/ReactBlocks-test.js b/packages/react-reconciler/src/__tests__/ReactBlocks-test.js
index 0d28a3359967d..6dfee5736c77b 100644
--- a/packages/react-reconciler/src/__tests__/ReactBlocks-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactBlocks-test.js
@@ -14,6 +14,7 @@ let useState;
 let Suspense;
 let block;
 let readString;
+let resolvePromises;
 let Scheduler;
 
 describe('ReactBlocks', () => {
@@ -28,15 +29,16 @@ describe('ReactBlocks', () => {
     useState = React.useState;
     Suspense = React.Suspense;
     const cache = new Map();
+    let unresolved = [];
     readString = function(text) {
       let entry = cache.get(text);
       if (!entry) {
         entry = {
           promise: new Promise(resolve => {
-            setTimeout(() => {
+            unresolved.push(() => {
               entry.resolved = true;
               resolve();
-            }, 100);
+            });
           }),
           resolved: false,
         };
@@ -47,6 +49,12 @@ describe('ReactBlocks', () => {
       }
       return text;
     };
+
+    resolvePromises = () => {
+      const res = unresolved;
+      unresolved = [];
+      res.forEach(r => r());
+    };
   });
 
   // @gate experimental
@@ -144,7 +152,7 @@ describe('ReactBlocks', () => {
     expect(ReactNoop).toMatchRenderedOutput('Loading...');
 
     await ReactNoop.act(async () => {
-      jest.advanceTimersByTime(1000);
+      await resolvePromises();
     });
 
     expect(ReactNoop).toMatchRenderedOutput(<span>Name: Sebastian</span>);
@@ -291,7 +299,7 @@ describe('ReactBlocks', () => {
       ReactNoop.render(<App Page={loadParent('Sebastian')} />);
     });
     await ReactNoop.act(async () => {
-      jest.advanceTimersByTime(1000);
+      await resolvePromises();
     });
     expect(ReactNoop).toMatchRenderedOutput(<span>Name: Sebastian</span>);
   });
@@ -336,7 +344,6 @@ describe('ReactBlocks', () => {
     });
     await ReactNoop.act(async () => {
       _setSuspend(false);
-      jest.advanceTimersByTime(1000);
     });
     expect(ReactNoop).toMatchRenderedOutput(<span>Sebastian</span>);
   });
diff --git a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
index 4c2a39718c9e4..bc37abbd322f4 100644
--- a/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactHooks-test.internal.js
@@ -31,7 +31,7 @@ describe('ReactHooks', () => {
     ReactTestRenderer = require('react-test-renderer');
     Scheduler = require('scheduler');
     ReactDOMServer = require('react-dom/server');
-    act = ReactTestRenderer.act;
+    act = ReactTestRenderer.unstable_concurrentAct;
   });
 
   if (__DEV__) {
@@ -782,7 +782,7 @@ describe('ReactHooks', () => {
     }
 
     const root = ReactTestRenderer.create(null);
-    ReactTestRenderer.act(() => {
+    act(() => {
       root.update(<Counter />);
     });
     expect(root).toMatchRenderedOutput('4');
@@ -806,7 +806,7 @@ describe('ReactHooks', () => {
     }
 
     const root = ReactTestRenderer.create(null);
-    ReactTestRenderer.act(() => {
+    act(() => {
       root.update(<Counter />);
     });
     expect(root).toMatchRenderedOutput('4');
@@ -829,7 +829,7 @@ describe('ReactHooks', () => {
     }
 
     const root = ReactTestRenderer.create(null);
-    ReactTestRenderer.act(() => {
+    act(() => {
       root.update(<Counter />);
     });
     expect(root).toMatchRenderedOutput('4');
@@ -1830,7 +1830,7 @@ describe('ReactHooks', () => {
       return null;
     }
 
-    ReactTestRenderer.act(() => {
+    act(() => {
       ReactTestRenderer.create(<A />);
     });
 
diff --git a/packages/react-reconciler/src/__tests__/ReactNoopRendererAct-test.js b/packages/react-reconciler/src/__tests__/ReactNoopRendererAct-test.js
index ca5d786f3fad4..6fad734ad5781 100644
--- a/packages/react-reconciler/src/__tests__/ReactNoopRendererAct-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactNoopRendererAct-test.js
@@ -9,7 +9,6 @@
 
 // sanity tests for ReactNoop.act()
 
-jest.useRealTimers();
 const React = require('react');
 const ReactNoop = require('react-noop-renderer');
 const Scheduler = require('scheduler');
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
index e806070e9cca1..54806dba475e9 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspense-test.internal.js
@@ -21,7 +21,7 @@ describe('ReactSuspense', () => {
     ReactFeatureFlags.enableSchedulerTracing = true;
     React = require('react');
     ReactTestRenderer = require('react-test-renderer');
-    act = ReactTestRenderer.act;
+    act = ReactTestRenderer.unstable_concurrentAct;
     Scheduler = require('scheduler');
     SchedulerTracing = require('scheduler/tracing');
     ReactCache = require('react-cache');
@@ -440,7 +440,7 @@ describe('ReactSuspense', () => {
         unstable_isConcurrent: true,
       });
 
-      await ReactTestRenderer.act(async () => {
+      await act(async () => {
         root.update(<App />);
         expect(Scheduler).toFlushAndYield([
           'shouldHideInParent: false',
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
index b6ed0d2be4d40..07b29090d0f61 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.js
@@ -575,7 +575,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
         <Suspense fallback="Loading...">
           <Text text="Sibling" />
           {shouldSuspend ? (
-            <AsyncText ms={10000} text={'Step ' + step} />
+            <AsyncText text={'Step ' + step} />
           ) : (
             <Text text={'Step ' + step} />
           )}
@@ -2595,7 +2595,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
           }
           return (
             <Suspense fallback={<Text text="Loading..." />}>
-              <AsyncText text={page} ms={5000} />
+              <AsyncText text={page} />
             </Suspense>
           );
         }
@@ -2616,8 +2616,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       });
 
       // Later we load the data.
-      Scheduler.unstable_advanceTime(5000);
-      await advanceTimers(5000);
+      await resolveText('A');
       expect(Scheduler).toHaveYielded(['Promise resolved [A]']);
       expect(Scheduler).toFlushAndYield(['A']);
       expect(ReactNoop.getChildren()).toEqual([span('A')]);
@@ -2635,8 +2634,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       });
 
       // Later we load the data.
-      Scheduler.unstable_advanceTime(3000);
-      await advanceTimers(3000);
+      await resolveText('B');
       expect(Scheduler).toHaveYielded(['Promise resolved [B]']);
       expect(Scheduler).toFlushAndYield(['B']);
       expect(ReactNoop.getChildren()).toEqual([span('B')]);
@@ -2754,12 +2752,14 @@ describe('ReactSuspenseWithNoopRenderer', () => {
     );
   });
 
+  // TODO: This test is specifically about avoided commits that suspend for a
+  // JND. We may remove this behavior.
   it("suspended commit remains suspended even if there's another update at same expiration", async () => {
     // Regression test
     function App({text}) {
       return (
         <Suspense fallback="Loading...">
-          <AsyncText ms={2000} text={text} />
+          <AsyncText text={text} />
         </Suspense>
       );
     }
@@ -2771,8 +2771,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
 
     // Resolve initial render
     await ReactNoop.act(async () => {
-      Scheduler.unstable_advanceTime(2000);
-      await advanceTimers(2000);
+      await resolveText('Initial');
     });
     expect(Scheduler).toHaveYielded([
       'Suspend! [Initial]',
@@ -2781,21 +2780,19 @@ describe('ReactSuspenseWithNoopRenderer', () => {
     ]);
     expect(root).toMatchRenderedOutput(<span prop="Initial" />);
 
-    // Update. Since showing a fallback would hide content that's already
-    // visible, it should suspend for a bit without committing.
     await ReactNoop.act(async () => {
+      // Update. Since showing a fallback would hide content that's already
+      // visible, it should suspend for a JND without committing.
       root.render(<App text="First update" />);
-
       expect(Scheduler).toFlushAndYield(['Suspend! [First update]']);
+
       // Should not display a fallback
       expect(root).toMatchRenderedOutput(<span prop="Initial" />);
-    });
 
-    // Update again. This should also suspend for a bit.
-    await ReactNoop.act(async () => {
+      // Update again. This should also suspend for a JND.
       root.render(<App text="Second update" />);
-
       expect(Scheduler).toFlushAndYield(['Suspend! [Second update]']);
+
       // Should not display a fallback
       expect(root).toMatchRenderedOutput(<span prop="Initial" />);
     });
@@ -2847,14 +2844,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       foo.setState({suspend: false});
     });
 
-    expect(Scheduler).toHaveYielded([
-      // First setState
-      'Foo',
-      // Second setState. This update was scheduled while we were in the
-      // middle of rendering the previous update, so it was pushed to a separate
-      // batch to avoid invalidating the work-in-progress tree.
-      'Foo',
-    ]);
+    expect(Scheduler).toHaveYielded(['Foo', 'Foo']);
     expect(root).toMatchRenderedOutput(<span prop="Foo" />);
   });
 
@@ -3846,8 +3836,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       await ReactNoop.act(async () => {
         await resolveText('b');
       });
-      expect(Scheduler).toHaveYielded(['Promise resolved [b]']);
-      expect(Scheduler).toFlushAndYield(['b']);
+      expect(Scheduler).toHaveYielded(['Promise resolved [b]', 'b']);
       // The bug was that the pending state got stuck forever.
       expect(root).toMatchRenderedOutput(<span prop="b" />);
     });
diff --git a/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js b/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
index 9fc02c7bdc101..55f8d3617c0de 100644
--- a/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
@@ -447,7 +447,7 @@ describe('SchedulingProfiler', () => {
       return didMount;
     }
 
-    ReactTestRenderer.act(() => {
+    ReactTestRenderer.unstable_concurrentAct(() => {
       ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
     });
 
@@ -480,7 +480,7 @@ describe('SchedulingProfiler', () => {
       return didRender;
     }
 
-    ReactTestRenderer.act(() => {
+    ReactTestRenderer.unstable_concurrentAct(() => {
       ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
     });
 
diff --git a/packages/react-reconciler/src/__tests__/useMutableSourceHydration-test.js b/packages/react-reconciler/src/__tests__/useMutableSourceHydration-test.js
index d21f955bc945c..2cd6881c94f73 100644
--- a/packages/react-reconciler/src/__tests__/useMutableSourceHydration-test.js
+++ b/packages/react-reconciler/src/__tests__/useMutableSourceHydration-test.js
@@ -26,7 +26,7 @@ describe('useMutableSourceHydration', () => {
     ReactDOMServer = require('react-dom/server');
     Scheduler = require('scheduler');
 
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     createMutableSource = React.unstable_createMutableSource;
     useMutableSource = React.unstable_useMutableSource;
   });
diff --git a/packages/react-refresh/src/__tests__/ReactFresh-test.js b/packages/react-refresh/src/__tests__/ReactFresh-test.js
index 4c3c932c90ac0..3b6f69b13e318 100644
--- a/packages/react-refresh/src/__tests__/ReactFresh-test.js
+++ b/packages/react-refresh/src/__tests__/ReactFresh-test.js
@@ -29,7 +29,7 @@ describe('ReactFresh', () => {
       ReactFreshRuntime.injectIntoGlobalHook(global);
       ReactDOM = require('react-dom');
       Scheduler = require('scheduler');
-      act = require('react-dom/test-utils').act;
+      act = require('react-dom/test-utils').unstable_concurrentAct;
       createReactClass = require('create-react-class/factory')(
         React.Component,
         React.isValidElement,
@@ -3748,7 +3748,7 @@ describe('ReactFresh', () => {
       React = require('react');
       ReactDOM = require('react-dom');
       Scheduler = require('scheduler');
-      act = require('react-dom/test-utils').act;
+      act = require('react-dom/test-utils').unstable_concurrentAct;
 
       // Important! Inject into the global hook *after* ReactDOM runs:
       ReactFreshRuntime = require('react-refresh/runtime');
diff --git a/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js b/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
index 4f3709a677ab8..f3538670e3717 100644
--- a/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
+++ b/packages/react-refresh/src/__tests__/ReactFreshIntegration-test.js
@@ -30,7 +30,7 @@ describe('ReactFreshIntegration', () => {
       ReactFreshRuntime = require('react-refresh/runtime');
       ReactFreshRuntime.injectIntoGlobalHook(global);
       ReactDOM = require('react-dom');
-      act = require('react-dom/test-utils').act;
+      act = require('react-dom/test-utils').unstable_concurrentAct;
       container = document.createElement('div');
       document.body.appendChild(container);
       exportsObj = undefined;
diff --git a/packages/react-test-renderer/src/ReactTestRenderer.js b/packages/react-test-renderer/src/ReactTestRenderer.js
index ffd0eaaf09c9a..a8a08aa7df318 100644
--- a/packages/react-test-renderer/src/ReactTestRenderer.js
+++ b/packages/react-test-renderer/src/ReactTestRenderer.js
@@ -20,6 +20,7 @@ import {
   injectIntoDevTools,
   batchedUpdates,
   act,
+  IsThisRendererActing,
 } from 'react-reconciler/src/ReactFiberReconciler';
 import {findCurrentFiberUsingSlowPath} from 'react-reconciler/src/ReactFiberTreeReflection';
 import {
@@ -44,10 +45,14 @@ import {
 import invariant from 'shared/invariant';
 import getComponentName from 'shared/getComponentName';
 import ReactVersion from 'shared/ReactVersion';
+import ReactSharedInternals from 'shared/ReactSharedInternals';
+import enqueueTask from 'shared/enqueueTask';
 
 import {getPublicInstance} from './ReactTestHostConfig';
 import {ConcurrentRoot, LegacyRoot} from 'react-reconciler/src/ReactRootTags';
 
+const {IsSomeRendererActing} = ReactSharedInternals;
+
 type TestRendererOptions = {
   createNodeMock: (element: React$Element<any>) => any,
   unstable_isConcurrent: boolean,
@@ -581,10 +586,124 @@ injectIntoDevTools({
   rendererPackageName: 'react-test-renderer',
 });
 
+let actingUpdatesScopeDepth = 0;
+
+// This version of `act` is only used by our tests. Unlike the public version
+// of `act`, it's designed to work identically in both production and
+// development. It may have slightly different behavior from the public
+// version, too, since our constraints in our test suite are not the same as
+// those of developers using React — we're testing React itself, as opposed to
+// building an app with React.
+// TODO: Migrate our tests to use ReactNoop. Although we would need to figure
+// out a solution for Relay, which has some Concurrent Mode tests.
+function unstable_concurrentAct(scope: () => void) {
+  if (Scheduler.unstable_flushAllWithoutAsserting === undefined) {
+    throw Error(
+      'This version of `act` requires a special mock build of Scheduler.',
+    );
+  }
+  if (setTimeout._isMockFunction !== true) {
+    throw Error(
+      "This version of `act` requires Jest's timer mocks " +
+        '(i.e. jest.useFakeTimers).',
+    );
+  }
+
+  const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
+  const previousIsSomeRendererActing = IsSomeRendererActing.current;
+  const previousIsThisRendererActing = IsThisRendererActing.current;
+  IsSomeRendererActing.current = true;
+  IsThisRendererActing.current = true;
+  actingUpdatesScopeDepth++;
+
+  const unwind = () => {
+    actingUpdatesScopeDepth--;
+    IsSomeRendererActing.current = previousIsSomeRendererActing;
+    IsThisRendererActing.current = previousIsThisRendererActing;
+    if (__DEV__) {
+      if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
+        // if it's _less than_ previousActingUpdatesScopeDepth, then we can
+        // assume the 'other' one has warned
+        console.error(
+          'You seem to have overlapping act() calls, this is not supported. ' +
+            'Be sure to await previous act() calls before making a new one. ',
+        );
+      }
+    }
+  };
+
+  // TODO: This would be way simpler if 1) we required a promise to be
+  // returned and 2) we could use async/await. Since it's only our used in
+  // our test suite, we should be able to.
+  try {
+    const thenable = batchedUpdates(scope);
+    if (
+      typeof thenable === 'object' &&
+      thenable !== null &&
+      typeof thenable.then === 'function'
+    ) {
+      return {
+        then(resolve, reject) {
+          thenable.then(
+            () => {
+              flushActWork(
+                () => {
+                  unwind();
+                  resolve();
+                },
+                error => {
+                  unwind();
+                  reject(error);
+                },
+              );
+            },
+            error => {
+              unwind();
+              reject(error);
+            },
+          );
+        },
+      };
+    } else {
+      try {
+        // TODO: Let's not support non-async scopes at all in our tests. Need to
+        // migrate existing tests.
+        let didFlushWork;
+        do {
+          didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+        } while (didFlushWork);
+      } finally {
+        unwind();
+      }
+    }
+  } catch (error) {
+    unwind();
+    throw error;
+  }
+}
+
+function flushActWork(resolve, reject) {
+  // TODO: Run timers to flush short Suspense fallbacks
+  // jest.runOnlyPendingTimers();
+  enqueueTask(() => {
+    try {
+      const didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+      if (didFlushWork) {
+        flushActWork(resolve, reject);
+      } else {
+        resolve();
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
 export {
   Scheduler as _Scheduler,
   create,
   /* eslint-disable-next-line camelcase */
   batchedUpdates as unstable_batchedUpdates,
   act,
+  unstable_concurrentAct,
 };
diff --git a/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js b/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
index 725b067b59f54..28cc0062e8a7b 100644
--- a/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
+++ b/packages/react-test-renderer/src/__tests__/ReactTestRendererAct-test.js
@@ -13,6 +13,8 @@ describe('ReactTestRenderer.act()', () => {
     Scheduler = require('scheduler');
     act = ReactTestRenderer.act;
   });
+
+  // @gate __DEV__
   it('can use .act() to flush effects', () => {
     function App(props) {
       const [ctr, setCtr] = React.useState(0);
@@ -56,6 +58,7 @@ describe('ReactTestRenderer.act()', () => {
   });
 
   describe('async', () => {
+    // @gate __DEV__
     it('should work with async/await', async () => {
       function fetch(url) {
         return Promise.resolve({
@@ -83,6 +86,7 @@ describe('ReactTestRenderer.act()', () => {
       expect(root.toJSON()).toEqual(['1', '2', '3']);
     });
 
+    // @gate __DEV__
     it('should not flush effects without also flushing microtasks', async () => {
       const {useEffect, useReducer} = React;
 
diff --git a/packages/react-transport-dom-relay/src/__tests__/ReactFlightDOMRelay-test.internal.js b/packages/react-transport-dom-relay/src/__tests__/ReactFlightDOMRelay-test.internal.js
index 67db8e74da9dd..31d4707248c74 100644
--- a/packages/react-transport-dom-relay/src/__tests__/ReactFlightDOMRelay-test.internal.js
+++ b/packages/react-transport-dom-relay/src/__tests__/ReactFlightDOMRelay-test.internal.js
@@ -18,7 +18,7 @@ describe('ReactFlightDOMRelay', () => {
   beforeEach(() => {
     jest.resetModules();
 
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     React = require('react');
     ReactDOM = require('react-dom');
     ReactDOMFlightRelayServer = require('react-transport-dom-relay/server');
diff --git a/packages/react-transport-dom-webpack/src/__tests__/ReactFlightDOM-test.js b/packages/react-transport-dom-webpack/src/__tests__/ReactFlightDOM-test.js
index 72aa615260f27..ecd71cea82d9f 100644
--- a/packages/react-transport-dom-webpack/src/__tests__/ReactFlightDOM-test.js
+++ b/packages/react-transport-dom-webpack/src/__tests__/ReactFlightDOM-test.js
@@ -37,7 +37,7 @@ describe('ReactFlightDOM', () => {
     jest.resetModules();
     webpackModules = {};
     webpackMap = {};
-    act = require('react-dom/test-utils').act;
+    act = require('react-dom/test-utils').unstable_concurrentAct;
     Stream = require('stream');
     React = require('react');
     ReactDOM = require('react-dom');
diff --git a/packages/react/src/__tests__/ReactDOMTracing-test.internal.js b/packages/react/src/__tests__/ReactDOMTracing-test.internal.js
index 66f548f9c39d5..e2c6bbe8f59dd 100644
--- a/packages/react/src/__tests__/ReactDOMTracing-test.internal.js
+++ b/packages/react/src/__tests__/ReactDOMTracing-test.internal.js
@@ -16,6 +16,7 @@ let ReactFeatureFlags;
 let Scheduler;
 let SchedulerTracing;
 let TestUtils;
+let act;
 let onInteractionScheduledWorkCompleted;
 let onInteractionTraced;
 let onWorkCanceled;
@@ -42,6 +43,8 @@ function loadModules() {
   SchedulerTracing = require('scheduler/tracing');
   TestUtils = require('react-dom/test-utils');
 
+  act = TestUtils.unstable_concurrentAct;
+
   onInteractionScheduledWorkCompleted = jest.fn();
   onInteractionTraced = jest.fn();
   onWorkCanceled = jest.fn();
@@ -118,7 +121,7 @@ describe('ReactDOMTracing', () => {
         const root = ReactDOM.createRoot(container);
         SchedulerTracing.unstable_trace('initialization', 0, () => {
           interaction = Array.from(SchedulerTracing.unstable_getCurrent())[0];
-          TestUtils.act(() => {
+          act(() => {
             root.render(
               <React.Profiler id="test" onRender={onRender}>
                 <App />
@@ -190,7 +193,7 @@ describe('ReactDOMTracing', () => {
         SchedulerTracing.unstable_trace('initialization', 0, () => {
           interaction = Array.from(SchedulerTracing.unstable_getCurrent())[0];
 
-          TestUtils.act(() => {
+          act(() => {
             root.render(
               <React.Profiler id="test" onRender={onRender}>
                 <App />
@@ -269,7 +272,7 @@ describe('ReactDOMTracing', () => {
         const root = ReactDOM.createRoot(container);
         SchedulerTracing.unstable_trace('initialization', 0, () => {
           interaction = Array.from(SchedulerTracing.unstable_getCurrent())[0];
-          TestUtils.act(() => {
+          act(() => {
             root.render(
               <React.Profiler id="test" onRender={onRender}>
                 <App />
@@ -364,7 +367,7 @@ describe('ReactDOMTracing', () => {
         const root = ReactDOM.createRoot(container);
 
         // Schedule some idle work without any interactions.
-        TestUtils.act(() => {
+        act(() => {
           root.render(
             <React.Profiler id="test" onRender={onRender}>
               <App />
@@ -468,7 +471,7 @@ describe('ReactDOMTracing', () => {
         const container = document.createElement('div');
         const root = ReactDOM.createRoot(container);
 
-        TestUtils.act(() => {
+        act(() => {
           root.render(
             <React.Profiler id="test" onRender={onRender}>
               <App />
@@ -568,7 +571,7 @@ describe('ReactDOMTracing', () => {
 
         let interaction;
 
-        TestUtils.act(() => {
+        act(() => {
           SchedulerTracing.unstable_trace('initialization', 0, () => {
             interaction = Array.from(SchedulerTracing.unstable_getCurrent())[0];
             // This render is only CPU bound. Nothing suspends.
diff --git a/packages/react/src/__tests__/ReactProfiler-test.internal.js b/packages/react/src/__tests__/ReactProfiler-test.internal.js
index 193f3d1ac7f15..c6022c92531c6 100644
--- a/packages/react/src/__tests__/ReactProfiler-test.internal.js
+++ b/packages/react/src/__tests__/ReactProfiler-test.internal.js
@@ -16,6 +16,7 @@ let ReactNoop;
 let Scheduler;
 let ReactCache;
 let ReactTestRenderer;
+let ReactTestRendererAct;
 let SchedulerTracing;
 let AdvanceTime;
 let AsyncText;
@@ -45,9 +46,11 @@ function loadModules({
   if (useNoopRenderer) {
     ReactNoop = require('react-noop-renderer');
     ReactTestRenderer = null;
+    ReactTestRendererAct = null;
   } else {
     ReactNoop = null;
     ReactTestRenderer = require('react-test-renderer');
+    ReactTestRendererAct = ReactTestRenderer.unstable_concurrentAct;
   }
 
   AdvanceTime = class extends React.Component {
@@ -374,7 +377,7 @@ describe('Profiler', () => {
         Scheduler.unstable_advanceTime(20); // 30 -> 50
 
         // Updating a sibling should not report a re-render.
-        ReactTestRenderer.act(updateProfilerSibling);
+        ReactTestRendererAct(updateProfilerSibling);
 
         expect(callback).not.toHaveBeenCalled();
       });
@@ -1495,7 +1498,7 @@ describe('Profiler', () => {
         const setCountRef = React.createRef(null);
 
         let renderer = null;
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer = ReactTestRenderer.create(
             <React.Profiler id="root-mount" onCommit={callback}>
               <React.Profiler id="a">
@@ -1523,7 +1526,7 @@ describe('Profiler', () => {
         expect(call[3]).toBe(2); // commit start time (before mutations or effects)
         expect(call[4]).toEqual(enableSchedulerTracing ? new Set() : undefined); // interaction events
 
-        ReactTestRenderer.act(() => setCountRef.current(count => count + 1));
+        ReactTestRendererAct(() => setCountRef.current(count => count + 1));
 
         expect(callback).toHaveBeenCalledTimes(2);
 
@@ -1536,7 +1539,7 @@ describe('Profiler', () => {
         expect(call[3]).toBe(1013); // commit start time (before mutations or effects)
         expect(call[4]).toEqual(enableSchedulerTracing ? new Set() : undefined); // interaction events
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="root-update" onCommit={callback}>
               <React.Profiler id="b">
@@ -1596,7 +1599,7 @@ describe('Profiler', () => {
 
         // Test an error that happens during an effect
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           ReactTestRenderer.create(
             <React.Profiler id="root" onCommit={callback}>
               <ErrorBoundary
@@ -1684,7 +1687,7 @@ describe('Profiler', () => {
 
         let renderer = null;
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer = ReactTestRenderer.create(
             <React.Profiler id="root" onCommit={callback}>
               <ErrorBoundary
@@ -1727,7 +1730,7 @@ describe('Profiler', () => {
 
         // Test an error that happens during an cleanup function
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="root" onCommit={callback}>
               <ErrorBoundary
@@ -1875,7 +1878,7 @@ describe('Profiler', () => {
         Scheduler.unstable_advanceTime(1);
 
         let renderer;
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer = ReactTestRenderer.create(
             <React.Profiler id="mount-test" onPostCommit={callback}>
               <ComponentWithEffects />
@@ -1897,7 +1900,7 @@ describe('Profiler', () => {
 
         Scheduler.unstable_advanceTime(1);
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="update-test" onPostCommit={callback}>
               <ComponentWithEffects />
@@ -1919,7 +1922,7 @@ describe('Profiler', () => {
 
         Scheduler.unstable_advanceTime(1);
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="unmount-test" onPostCommit={callback} />,
           );
@@ -1961,7 +1964,7 @@ describe('Profiler', () => {
 
         Scheduler.unstable_advanceTime(1);
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           ReactTestRenderer.create(
             <React.Profiler id="mount-test" onPostCommit={callback}>
               <ComponentWithEffects />
@@ -2015,7 +2018,7 @@ describe('Profiler', () => {
         const setCountRef = React.createRef(null);
 
         let renderer = null;
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer = ReactTestRenderer.create(
             <React.Profiler id="root-mount" onPostCommit={callback}>
               <React.Profiler id="a">
@@ -2043,7 +2046,7 @@ describe('Profiler', () => {
         expect(call[3]).toBe(2); // commit start time (before mutations or effects)
         expect(call[4]).toEqual(enableSchedulerTracing ? new Set() : undefined); // interaction events
 
-        ReactTestRenderer.act(() => setCountRef.current(count => count + 1));
+        ReactTestRendererAct(() => setCountRef.current(count => count + 1));
 
         expect(callback).toHaveBeenCalledTimes(2);
 
@@ -2056,7 +2059,7 @@ describe('Profiler', () => {
         expect(call[3]).toBe(1013); // commit start time (before mutations or effects)
         expect(call[4]).toEqual(enableSchedulerTracing ? new Set() : undefined); // interaction events
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="root-update" onPostCommit={callback}>
               <React.Profiler id="b">
@@ -2116,7 +2119,7 @@ describe('Profiler', () => {
 
         // Test an error that happens during an effect
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           ReactTestRenderer.create(
             <React.Profiler id="root" onPostCommit={callback}>
               <ErrorBoundary
@@ -2205,7 +2208,7 @@ describe('Profiler', () => {
 
         let renderer = null;
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer = ReactTestRenderer.create(
             <React.Profiler id="root" onPostCommit={callback}>
               <ErrorBoundary
@@ -2248,7 +2251,7 @@ describe('Profiler', () => {
 
         // Test an error that happens during an cleanup function
 
-        ReactTestRenderer.act(() => {
+        ReactTestRendererAct(() => {
           renderer.update(
             <React.Profiler id="root" onPostCommit={callback}>
               <ErrorBoundary
@@ -2327,7 +2330,7 @@ describe('Profiler', () => {
 
           Scheduler.unstable_advanceTime(1);
 
-          ReactTestRenderer.act(() => {
+          ReactTestRendererAct(() => {
             SchedulerTracing.unstable_trace(
               interaction.name,
               interaction.timestamp,
diff --git a/packages/use-subscription/src/__tests__/useSubscription-test.js b/packages/use-subscription/src/__tests__/useSubscription-test.js
index 52e15fd428229..6e0a9e5045661 100644
--- a/packages/use-subscription/src/__tests__/useSubscription-test.js
+++ b/packages/use-subscription/src/__tests__/useSubscription-test.js
@@ -27,7 +27,7 @@ describe('useSubscription', () => {
     ReactTestRenderer = require('react-test-renderer');
     Scheduler = require('scheduler');
 
-    act = ReactTestRenderer.act;
+    act = ReactTestRenderer.unstable_concurrentAct;
 
     BehaviorSubject = require('rxjs').BehaviorSubject;
     ReplaySubject = require('rxjs').ReplaySubject;
diff --git a/scripts/jest/shouldIgnoreConsoleError.js b/scripts/jest/shouldIgnoreConsoleError.js
index cae46ac7c8c32..4ea96751c073b 100644
--- a/scripts/jest/shouldIgnoreConsoleError.js
+++ b/scripts/jest/shouldIgnoreConsoleError.js
@@ -25,16 +25,6 @@ module.exports = function shouldIgnoreConsoleError(format, args) {
       // They are noisy too so we'll try to ignore them.
       return true;
     }
-    if (
-      format.indexOf(
-        'act(...) is not supported in production builds of React'
-      ) === 0
-    ) {
-      // We don't yet support act() for prod builds, and warn for it.
-      // But we'd like to use act() ourselves for prod builds.
-      // Let's ignore the warning and #yolo.
-      return true;
-    }
   }
   // Looks legit
   return false;