Added memoization test for interrupted low-priority renders

Test added to verify that a high-priority update can reuse the children from an aborted low-priority update if  returns false.

scripts/fiber/tests-passing.txt

@@ -1159,6 +1159,7 @@ src/renderers/shared/fiber/__tests__/ReactIncremental-test.js
 * reads context when setState is above the provider
 * maintains the correct context when providers bail out due to low priority
 * maintains the correct context when unwinding due to an error in render
+* should reuse memoized work after an interrupted low-priority render
 
 src/renderers/shared/fiber/__tests__/ReactIncrementalErrorHandling-test.js
 * catches render error in a boundary during full deferred mounting

src/renderers/shared/fiber/__tests__/ReactIncremental-test.js

@@ -2021,4 +2021,91 @@ describe('ReactIncremental', () => {
     });
     ReactNoop.flush();
   });
+
+  it('should reuse memoized work after an interrupted low-priority render', () => {
+    let cduNextProps = null;
+    let cduPrevProps = null;
+    let scuNextProps = null;
+    let scuPrevProps = null;
+    let renderCounter = 0;
+
+    function SecondChild(props) {
+      return <span>{props.children}</span>;
+    }
+
+    class FirstChild extends React.Component {
+      componentDidUpdate(prevProps, prevState) {
+        cduNextProps = this.props;
+        cduPrevProps = prevProps;
+      }
+      shouldComponentUpdate(nextProps, nextState) {
+        scuNextProps = nextProps;
+        scuPrevProps = this.props;
+        return this.props.children !== nextProps.children;
+      }
+      render() {
+        renderCounter++;
+        return <span>{this.props.children}</span>;
+      }
+    }
+
+    class Middle extends React.Component {
+      render() {
+        return (
+          <div>
+            <FirstChild>{this.props.children}</FirstChild>
+            <SecondChild>{this.props.children}</SecondChild>
+          </div>
+        );
+      }
+    }
+
+    function Root(props) {
+      return (
+        <div hidden={true}>
+          <Middle {...props} />
+        </div>
+      );
+    }
+
+    // Initial render of the entire tree.
+    // Renders: Root, Middle, FirstChild, SecondChild
+    ReactNoop.render(<Root>A</Root>);
+    ReactNoop.flush();
+
+    expect(renderCounter).toBe(1);
+
+    // Schedule low priority work to update children.
+    // Renders: Root
+    ReactNoop.render(<Root>B</Root>);
+    ReactNoop.flushDeferredPri(20);
+
+    // Children are now pending rendering.
+    // Give them enough time to partially render.
+    // Renders: Middle, FirstChild
+    ReactNoop.flushDeferredPri(30 + 5);
+
+    // At this point our FirstChild component has rendered a second time,
+    // But since the render is not completed cDU should not be called yet.
+    expect(renderCounter).toBe(2);
+    expect(scuPrevProps.children).toEqual('A');
+    expect(scuNextProps.children).toEqual('B');
+    expect(cduPrevProps).toEqual(null);
+    expect(cduNextProps).toEqual(null);
+
+    // Next interrupt the partial render with higher priority work.
+    // The in-progress child content will bailout.
+    // Renders: Root, Middle, FirstChild, SecondChild
+    ReactNoop.render(<Root>B</Root>);
+    ReactNoop.flush();
+
+    // At this point the higher priority render has completed.
+    // Since FirstChild props didn't change, sCU returned false.
+    // The previous memoized copy should be used.
+    expect(renderCounter).toBe(2);
+    expect(scuPrevProps.children).toEqual('B');
+    expect(scuNextProps.children).toEqual('B');
+    expect(cduPrevProps.children).toEqual('A');
+    expect(cduNextProps.children).toEqual('B');
+  });
 });