Add back accidentally deleted test comments (#26294)

The codemod I used in #26288 accidentally caused some comments to be
deleted. Because not all affected lines included comments, I didn't
notice until after landing.

This adds the comments back.

packages/react-reconciler/src/__tests__/ReactBatching-test.internal.js

@@ -166,9 +166,11 @@ describe('ReactBlockingMode', () => {
  assertLog(['A1', 'B1']);
  expect(root).toMatchRenderedOutput('A1B1');
  } else {
+ // Only the second update should have flushed synchronously
  assertLog(['B1']);
  expect(root).toMatchRenderedOutput('A0B1');
 
+ // Now flush the first update
  await waitForAll(['A1']);
  expect(root).toMatchRenderedOutput('A1B1');
  }

packages/react-reconciler/src/__tests__/ReactCPUSuspense-test.js

@@ -143,6 +143,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
  </>,
  );
  });
+ // Inner contents finish in separate commit from outer
  assertLog(['Inner']);
  expect(root).toMatchRenderedOutput(
  <>
@@ -178,6 +179,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
  await act(async () => {
  root.render(<App />);
  });
+ // Inner contents finish in separate commit from outer
  assertLog(['Outer', 'Loading...', 'Inner [0]']);
  expect(root).toMatchRenderedOutput(
  <>
@@ -190,6 +192,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
  await act(async () => {
  setCount(1);
  });
+ // Entire update finishes in a single commit
  assertLog(['Outer', 'Inner [1]']);
  expect(root).toMatchRenderedOutput(
  <>
@@ -227,6 +230,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
  </>,
  );
  });
+ // Inner contents suspended, so we continue showing a fallback.
  assertLog(['Suspend! [Inner]']);
  expect(root).toMatchRenderedOutput(
  <>
@@ -276,6 +280,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
  await act(async () => {
  root.render(<App />);
  });
+ // Each level commits separately
  assertLog(['A', 'Loading B...', 'B', 'Loading C...', 'C']);
  expect(root).toMatchRenderedOutput(
  <>

packages/react-reconciler/src/__tests__/ReactCache-test.js

@@ -219,6 +219,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -245,6 +246,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -273,6 +275,8 @@ describe('ReactCache', () => {
  root.render(<App showMore={false} />);
  });
 
+ // Even though there are two new <Cache /> trees, they should share the same
+ // data cache. So there should be only a single cache miss for A.
  assertLog(['Cache miss! [A]', 'Loading...', 'Loading...']);
  expect(root).toMatchRenderedOutput('Loading...Loading...');
 
@@ -285,6 +289,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -320,6 +325,8 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render(<App showMore={true} />);
  });
+ // Even though there are two new <Cache /> trees, they should share the same
+ // data cache. So there should be only a single cache miss for A.
  assertLog(['Cache miss! [A]', 'Loading...', 'Loading...']);
  expect(root).toMatchRenderedOutput('Loading...Loading...');
 
@@ -332,6 +339,9 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // cleanup occurs for the cache shared by the inner cache boundaries (which
+ // are not shared w the root because they were added in an update)
+ // note that no cache is created for the root since the cache is never accessed
  assertLog(['Cache cleanup: A [v1]']);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -356,6 +366,8 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render(<App />);
  });
+ // Even though there is a nested <Cache /> boundary, it should share the same
+ // data cache as the root. So there should be only a single cache miss for A.
  assertLog(['Cache miss! [A]', 'Loading...']);
  expect(root).toMatchRenderedOutput('Loading...');
 
@@ -368,6 +380,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  },
@@ -412,6 +425,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -468,6 +482,8 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye!');
  });
+ // Cleanup occurs for the *second* cache instance: the first is still
+ // referenced by the root
  assertLog(['Cache cleanup: A [v2]']);
  expect(root).toMatchRenderedOutput('Bye!');
  });
@@ -549,6 +565,7 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye');
  });
+ // no cleanup: cache is still retained at the root
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -728,12 +745,14 @@ describe('ReactCache', () => {
  await act(async () => {
  resolveMostRecentTextCache('A');
  });
+ // Note that the version has updated, and the previous cache is cleared
  assertLog(['A [v2]', 'Cache cleanup: A [v1]']);
  expect(root).toMatchRenderedOutput('A [v2]');
 
  await act(async () => {
  root.render('Bye');
  });
+ // the original root cache already cleaned up when the refresh completed
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -781,12 +800,14 @@ describe('ReactCache', () => {
  await act(async () => {
  resolveMostRecentTextCache('A');
  });
+ // Note that the version has updated, and the previous cache is cleared
  assertLog(['A [v2]']);
  expect(root).toMatchRenderedOutput('A [v2]');
 
  await act(async () => {
  root.render('Bye');
  });
+ // the original root cache already cleaned up when the refresh completed
  assertLog([]);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -841,12 +862,15 @@ describe('ReactCache', () => {
  }),
  );
  });
+ // The root should re-render without a cache miss.
+ // The cache is not cleared up yet, since it's still reference by the root
  assertLog(['A [v2]']);
  expect(root).toMatchRenderedOutput('A [v2]');
 
  await act(async () => {
  root.render('Bye');
  });
+ // the refreshed cache boundary is unmounted and cleans up
  assertLog(['Cache cleanup: A [v2]']);
  expect(root).toMatchRenderedOutput('Bye');
  });
@@ -920,6 +944,8 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye!');
  });
+ // Unmounting children releases the refreshed cache instance only; the root
+ // still retains the original cache instance used for the first render
  assertLog(['Cache cleanup: A [v3]']);
  expect(root).toMatchRenderedOutput('Bye!');
  });
@@ -967,6 +993,8 @@ describe('ReactCache', () => {
  root.render(<App showMore={true} />);
  });
 
+ // Even though there are two new <Cache /> trees, they should share the same
+ // data cache. So there should be only a single cache miss for A.
  assertLog(['Cache miss! [A]', 'Loading...', 'Loading...']);
  expect(root).toMatchRenderedOutput('Loading...Loading...');
 
@@ -1064,6 +1092,9 @@ describe('ReactCache', () => {
  await act(async () => {
  root.render('Bye!');
  });
+ // Unmounting children releases both cache boundaries, but the original
+ // cache instance (used by second boundary) is still referenced by the root.
+ // only the second cache instance is freed.
  assertLog(['Cache cleanup: A [v2]']);
  expect(root).toMatchRenderedOutput('Bye!');
  },

packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js

@@ -339,6 +339,11 @@ describe('ReactLazyContextPropagation', () => {
  setOtherValue(1);
  setOtherValue(0);
  });
+ // NOTE: If this didn't yield anything, that indicates that we never visited
+ // the consumer during the render phase, which probably means the eager
+ // bailout mechanism kicked in. Because we're testing the _lazy_ bailout
+ // mechanism, update this test to foil the _eager_ bailout, somehow. Perhaps
+ // by switching to useReducer.
  assertLog(['Consumer']);
  expect(root).toMatchRenderedOutput('0');
  });

packages/react-reconciler/src/__tests__/ReactDeferredValue-test.js

@@ -78,6 +78,7 @@ describe('ReactDeferredValue', () => {
  root.render(<App value={2} />);
 
  await waitForPaint(['Original: 2']);
+ // The deferred value updates in a separate render
  await waitForPaint(['Deferred: 2']);
  });
  expect(root).toMatchRenderedOutput(
@@ -92,6 +93,7 @@ describe('ReactDeferredValue', () => {
  startTransition(() => {
  root.render(<App value={3} />);
  });
+ // The deferred value updates in the same render as the original
  await waitForPaint(['Original: 3', 'Deferred: 3']);
  });
  expect(root).toMatchRenderedOutput(
@@ -137,6 +139,7 @@ describe('ReactDeferredValue', () => {
  root.render(<App value={2} />);
 
  await waitForPaint(['Original: 2']);
+ // The deferred value updates in a separate render
  await waitForPaint(['Deferred: 2']);
  });
  expect(root).toMatchRenderedOutput(
@@ -151,6 +154,7 @@ describe('ReactDeferredValue', () => {
  startTransition(() => {
  root.render(<App value={3} />);
  });
+ // The deferred value updates in the same render as the original
  await waitForPaint(['Original: 3', 'Deferred: 3']);
  });
  expect(root).toMatchRenderedOutput(
@@ -201,6 +205,7 @@ describe('ReactDeferredValue', () => {
  root.render(<App value={2} />);
 
  await waitForPaint(['Original: 2']);
+ // The deferred value updates in a separate render
  await waitForPaint(['Deferred: 2']);
  });
  expect(root).toMatchRenderedOutput(
@@ -215,6 +220,7 @@ describe('ReactDeferredValue', () => {
  startTransition(() => {
  root.render(<App value={3} />);
  });
+ // The deferred value updates in the same render as the original
  await waitForPaint(['Original: 3', 'Deferred: 3']);
  });
  expect(root).toMatchRenderedOutput(
@@ -270,6 +276,9 @@ describe('ReactDeferredValue', () => {
  startTransition(() => {
  root.render(<App value={2} />);
  });
+ // In the regression, the memoized value was not updated during non-urgent
+ // updates, so this would flip the deferred value back to the initial
+ // value (1) instead of reusing the current one (2).
  await waitForPaint(['Original: 2', 'Deferred: 2']);
  expect(root).toMatchRenderedOutput(
  <div>

packages/react-reconciler/src/__tests__/ReactExpiration-test.js

@@ -171,14 +171,17 @@ describe('ReactExpiration', () => {
  });
  // Advance the timer.
  Scheduler.unstable_advanceTime(2000);
+ // Partially flush the first update, then interrupt it.
  await waitFor(['A [render]']);
  interrupt();
 
+ // Don't advance time by enough to expire the first update.
  assertLog([]);
  expect(ReactNoop).toMatchRenderedOutput(null);
 
  // Schedule another update.
  ReactNoop.render(<TextClass text="B" />);
+ // Both updates are batched
  await waitForAll(['B [render]', 'B [commit]']);
  expect(ReactNoop).toMatchRenderedOutput(<span prop="B" />);
 
@@ -190,6 +193,8 @@ describe('ReactExpiration', () => {
  expect(ReactNoop).toMatchRenderedOutput(<span prop="B" />);
  // Schedule another update.
  ReactNoop.render(<TextClass text="B" />);
+ // The updates should flush in the same batch, since as far as the scheduler
+ // knows, they may have occurred inside the same event.
  await waitForAll(['B [render]', 'B [commit]']);
  });
 
@@ -223,14 +228,17 @@ describe('ReactExpiration', () => {
  });
  // Advance the timer.
  Scheduler.unstable_advanceTime(2000);
+ // Partially flush the first update, then interrupt it.
  await waitFor(['A [render]']);
  interrupt();
 
+ // Don't advance time by enough to expire the first update.
  assertLog([]);
  expect(ReactNoop).toMatchRenderedOutput(null);
 
  // Schedule another update.
  ReactNoop.render(<TextClass text="B" />);
+ // Both updates are batched
  await waitForAll(['B [render]', 'B [commit]']);
  expect(ReactNoop).toMatchRenderedOutput(<span prop="B" />);
 
@@ -247,6 +255,8 @@ describe('ReactExpiration', () => {
 
  // Schedule another update.
  ReactNoop.render(<TextClass text="B" />);
+ // The updates should flush in the same batch, since as far as the scheduler
+ // knows, they may have occurred inside the same event.
  await waitForAll(['B [render]', 'B [commit]']);
  },
  );
@@ -471,7 +481,9 @@ describe('ReactExpiration', () => {
  // In other words, we can flush just the first child without flushing
  // the rest.
  Scheduler.unstable_flushNumberOfYields(1);
+ // Yield right after first child.
  assertLog(['Sync pri: 1']);
+ // Now do the rest.
  await waitForAll(['Normal pri: 1']);
  });
  expect(root).toMatchRenderedOutput('Sync pri: 1, Normal pri: 1');
@@ -533,6 +545,7 @@ describe('ReactExpiration', () => {
  await waitFor(['Sync pri: 0']);
  updateSyncPri();
  });
+ // Same thing should happen as last time
  assertLog([
  // Interrupt idle update to render sync update
  'Sync pri: 1',
@@ -733,6 +746,7 @@ describe('ReactExpiration', () => {
  Scheduler.unstable_flushNumberOfYields(1);
  assertLog(['A1', 'B1', 'C1']);
  });
+ // The effect flushes after paint.
  assertLog(['Effect: 1']);
  });
 });