1. /**

  2.  * Copyright (c) Meta Platforms, Inc. and affiliates.

  3.  *

  4.  * This source code is licensed under the MIT license found in the

  5.  * LICENSE file in the root directory of this source tree.

  6.  *

  7.  * @emails react-core

  8.  */

  9. 

  10. 'use strict';

  11. 

  12. let PropTypes;

  13. let React;

  14. let ReactDOM;

  15. let act;

  16. let ReactFeatureFlags;

  17. let Scheduler;

  18. 

  19. describe('ReactErrorBoundaries', () => {

  20.   let BrokenConstructor;

  21.   let BrokenComponentWillMount;

  22.   let BrokenComponentDidMount;

  23.   let BrokenComponentWillReceiveProps;

  24.   let BrokenComponentWillUpdate;

  25.   let BrokenComponentDidUpdate;

  26.   let BrokenComponentWillUnmount;

  27.   let BrokenRenderErrorBoundary;

  28.   let BrokenComponentWillMountErrorBoundary;

  29.   let BrokenComponentDidMountErrorBoundary;

  30.   let BrokenRender;

  31.   let BrokenUseEffect;

  32.   let BrokenUseLayoutEffect;

  33.   let ErrorBoundary;

  34.   let ErrorMessage;

  35.   let NoopErrorBoundary;

  36.   let RetryErrorBoundary;

  37.   let Normal;

  38.   let assertLog;

  39. 

  40.   beforeEach(() => {

  41.     jest.useFakeTimers();

  42.     jest.resetModules();

  43.     PropTypes = require('prop-types');

  44.     ReactFeatureFlags = require('shared/ReactFeatureFlags');

  45.     ReactFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback = false;

  46.     ReactDOM = require('react-dom');

  47.     React = require('react');

  48.     act = require('internal-test-utils').act;

  49.     Scheduler = require('scheduler');

  50. 

  51.     const InternalTestUtils = require('internal-test-utils');

  52.     assertLog = InternalTestUtils.assertLog;

  53. 

  54.     BrokenConstructor = class extends React.Component {

  55.       constructor(props) {

  56.         super(props);

  57.         Scheduler.log('BrokenConstructor constructor [!]');

  58.         throw new Error('Hello');

  59.       }

  60.       render() {

  61.         Scheduler.log('BrokenConstructor render');

  62.         return <div>{this.props.children}</div>;

  63.       }

  64.       UNSAFE_componentWillMount() {

  65.         Scheduler.log('BrokenConstructor componentWillMount');

  66.       }

  67.       componentDidMount() {

  68.         Scheduler.log('BrokenConstructor componentDidMount');

  69.       }

  70.       UNSAFE_componentWillReceiveProps() {

  71.         Scheduler.log('BrokenConstructor componentWillReceiveProps');

  72.       }

  73.       UNSAFE_componentWillUpdate() {

  74.         Scheduler.log('BrokenConstructor componentWillUpdate');

  75.       }

  76.       componentDidUpdate() {

  77.         Scheduler.log('BrokenConstructor componentDidUpdate');

  78.       }

  79.       componentWillUnmount() {

  80.         Scheduler.log('BrokenConstructor componentWillUnmount');

  81.       }

  82.     };

  83. 

  84.     BrokenComponentWillMount = class extends React.Component {

  85.       constructor(props) {

  86.         super(props);

  87.         Scheduler.log('BrokenComponentWillMount constructor');

  88.       }

  89.       render() {

  90.         Scheduler.log('BrokenComponentWillMount render');

  91.         return <div>{this.props.children}</div>;

  92.       }

  93.       UNSAFE_componentWillMount() {

  94.         Scheduler.log('BrokenComponentWillMount componentWillMount [!]');

  95.         throw new Error('Hello');

  96.       }

  97.       componentDidMount() {

  98.         Scheduler.log('BrokenComponentWillMount componentDidMount');

  99.       }

  100.       UNSAFE_componentWillReceiveProps() {

  101.         Scheduler.log('BrokenComponentWillMount componentWillReceiveProps');

  102.       }

  103.       UNSAFE_componentWillUpdate() {

  104.         Scheduler.log('BrokenComponentWillMount componentWillUpdate');

  105.       }

  106.       componentDidUpdate() {

  107.         Scheduler.log('BrokenComponentWillMount componentDidUpdate');

  108.       }

  109.       componentWillUnmount() {

  110.         Scheduler.log('BrokenComponentWillMount componentWillUnmount');

  111.       }

  112.     };

  113. 

  114.     BrokenComponentDidMount = class extends React.Component {

  115.       constructor(props) {

  116.         super(props);

  117.         Scheduler.log('BrokenComponentDidMount constructor');

  118.       }

  119.       render() {

  120.         Scheduler.log('BrokenComponentDidMount render');

  121.         return <div>{this.props.children}</div>;

  122.       }

  123.       UNSAFE_componentWillMount() {

  124.         Scheduler.log('BrokenComponentDidMount componentWillMount');

  125.       }

  126.       componentDidMount() {

  127.         Scheduler.log('BrokenComponentDidMount componentDidMount [!]');

  128.         throw new Error('Hello');

  129.       }

  130.       UNSAFE_componentWillReceiveProps() {

  131.         Scheduler.log('BrokenComponentDidMount componentWillReceiveProps');

  132.       }

  133.       UNSAFE_componentWillUpdate() {

  134.         Scheduler.log('BrokenComponentDidMount componentWillUpdate');

  135.       }

  136.       componentDidUpdate() {

  137.         Scheduler.log('BrokenComponentDidMount componentDidUpdate');

  138.       }

  139.       componentWillUnmount() {

  140.         Scheduler.log('BrokenComponentDidMount componentWillUnmount');

  141.       }

  142.     };

  143. 

  144.     BrokenComponentWillReceiveProps = class extends React.Component {

  145.       constructor(props) {

  146.         super(props);

  147.         Scheduler.log('BrokenComponentWillReceiveProps constructor');

  148.       }

  149.       render() {

  150.         Scheduler.log('BrokenComponentWillReceiveProps render');

  151.         return <div>{this.props.children}</div>;

  152.       }

  153.       UNSAFE_componentWillMount() {

  154.         Scheduler.log('BrokenComponentWillReceiveProps componentWillMount');

  155.       }

  156.       componentDidMount() {

  157.         Scheduler.log('BrokenComponentWillReceiveProps componentDidMount');

  158.       }

  159.       UNSAFE_componentWillReceiveProps() {

  160.         Scheduler.log(

  161.           'BrokenComponentWillReceiveProps componentWillReceiveProps [!]',

  162.         );

  163.         throw new Error('Hello');

  164.       }

  165.       UNSAFE_componentWillUpdate() {

  166.         Scheduler.log('BrokenComponentWillReceiveProps componentWillUpdate');

  167.       }

  168.       componentDidUpdate() {

  169.         Scheduler.log('BrokenComponentWillReceiveProps componentDidUpdate');

  170.       }

  171.       componentWillUnmount() {

  172.         Scheduler.log('BrokenComponentWillReceiveProps componentWillUnmount');

  173.       }

  174.     };

  175. 

  176.     BrokenComponentWillUpdate = class extends React.Component {

  177.       constructor(props) {

  178.         super(props);

  179.         Scheduler.log('BrokenComponentWillUpdate constructor');

  180.       }

  181.       render() {

  182.         Scheduler.log('BrokenComponentWillUpdate render');

  183.         return <div>{this.props.children}</div>;

  184.       }

  185.       UNSAFE_componentWillMount() {

  186.         Scheduler.log('BrokenComponentWillUpdate componentWillMount');

  187.       }

  188.       componentDidMount() {

  189.         Scheduler.log('BrokenComponentWillUpdate componentDidMount');

  190.       }

  191.       UNSAFE_componentWillReceiveProps() {

  192.         Scheduler.log('BrokenComponentWillUpdate componentWillReceiveProps');

  193.       }

  194.       UNSAFE_componentWillUpdate() {

  195.         Scheduler.log('BrokenComponentWillUpdate componentWillUpdate [!]');

  196.         throw new Error('Hello');

  197.       }

  198.       componentDidUpdate() {

  199.         Scheduler.log('BrokenComponentWillUpdate componentDidUpdate');

  200.       }

  201.       componentWillUnmount() {

  202.         Scheduler.log('BrokenComponentWillUpdate componentWillUnmount');

  203.       }

  204.     };

  205. 

  206.     BrokenComponentDidUpdate = class extends React.Component {

  207.       static defaultProps = {

  208.         errorText: 'Hello',

  209.       };

  210.       constructor(props) {

  211.         super(props);

  212.         Scheduler.log('BrokenComponentDidUpdate constructor');

  213.       }

  214.       render() {

  215.         Scheduler.log('BrokenComponentDidUpdate render');

  216.         return <div>{this.props.children}</div>;

  217.       }

  218.       UNSAFE_componentWillMount() {

  219.         Scheduler.log('BrokenComponentDidUpdate componentWillMount');

  220.       }

  221.       componentDidMount() {

  222.         Scheduler.log('BrokenComponentDidUpdate componentDidMount');

  223.       }

  224.       UNSAFE_componentWillReceiveProps() {

  225.         Scheduler.log('BrokenComponentDidUpdate componentWillReceiveProps');

  226.       }

  227.       UNSAFE_componentWillUpdate() {

  228.         Scheduler.log('BrokenComponentDidUpdate componentWillUpdate');

  229.       }

  230.       componentDidUpdate() {

  231.         Scheduler.log('BrokenComponentDidUpdate componentDidUpdate [!]');

  232.         throw new Error(this.props.errorText);

  233.       }

  234.       componentWillUnmount() {

  235.         Scheduler.log('BrokenComponentDidUpdate componentWillUnmount');

  236.       }

  237.     };

  238. 

  239.     BrokenComponentWillUnmount = class extends React.Component {

  240.       static defaultProps = {

  241.         errorText: 'Hello',

  242.       };

  243.       constructor(props) {

  244.         super(props);

  245.         Scheduler.log('BrokenComponentWillUnmount constructor');

  246.       }

  247.       render() {

  248.         Scheduler.log('BrokenComponentWillUnmount render');

  249.         return <div>{this.props.children}</div>;

  250.       }

  251.       UNSAFE_componentWillMount() {

  252.         Scheduler.log('BrokenComponentWillUnmount componentWillMount');

  253.       }

  254.       componentDidMount() {

  255.         Scheduler.log('BrokenComponentWillUnmount componentDidMount');

  256.       }

  257.       UNSAFE_componentWillReceiveProps() {

  258.         Scheduler.log('BrokenComponentWillUnmount componentWillReceiveProps');

  259.       }

  260.       UNSAFE_componentWillUpdate() {

  261.         Scheduler.log('BrokenComponentWillUnmount componentWillUpdate');

  262.       }

  263.       componentDidUpdate() {

  264.         Scheduler.log('BrokenComponentWillUnmount componentDidUpdate');

  265.       }

  266.       componentWillUnmount() {

  267.         Scheduler.log('BrokenComponentWillUnmount componentWillUnmount [!]');

  268.         throw new Error(this.props.errorText);

  269.       }

  270.     };

  271. 

  272.     BrokenComponentWillMountErrorBoundary = class extends React.Component {

  273.       constructor(props) {

  274.         super(props);

  275.         this.state = {error: null};

  276.         Scheduler.log('BrokenComponentWillMountErrorBoundary constructor');

  277.       }

  278.       render() {

  279.         if (this.state.error) {

  280.           Scheduler.log('BrokenComponentWillMountErrorBoundary render error');

  281.           return <div>Caught an error: {this.state.error.message}.</div>;

  282.         }

  283.         Scheduler.log('BrokenComponentWillMountErrorBoundary render success');

  284.         return <div>{this.props.children}</div>;

  285.       }

  286.       UNSAFE_componentWillMount() {

  287.         Scheduler.log(

  288.           'BrokenComponentWillMountErrorBoundary componentWillMount [!]',

  289.         );

  290.         throw new Error('Hello');

  291.       }

  292.       componentDidMount() {

  293.         Scheduler.log(

  294.           'BrokenComponentWillMountErrorBoundary componentDidMount',

  295.         );

  296.       }

  297.       componentWillUnmount() {

  298.         Scheduler.log(

  299.           'BrokenComponentWillMountErrorBoundary componentWillUnmount',

  300.         );

  301.       }

  302.       static getDerivedStateFromError(error) {

  303.         Scheduler.log(

  304.           'BrokenComponentWillMountErrorBoundary static getDerivedStateFromError',

  305.         );

  306.         return {error};

  307.       }

  308.     };

  309. 

  310.     BrokenComponentDidMountErrorBoundary = class extends React.Component {

  311.       constructor(props) {

  312.         super(props);

  313.         this.state = {error: null};

  314.         Scheduler.log('BrokenComponentDidMountErrorBoundary constructor');

  315.       }

  316.       render() {

  317.         if (this.state.error) {

  318.           Scheduler.log('BrokenComponentDidMountErrorBoundary render error');

  319.           return <div>Caught an error: {this.state.error.message}.</div>;

  320.         }

  321.         Scheduler.log('BrokenComponentDidMountErrorBoundary render success');

  322.         return <div>{this.props.children}</div>;

  323.       }

  324.       UNSAFE_componentWillMount() {

  325.         Scheduler.log(

  326.           'BrokenComponentDidMountErrorBoundary componentWillMount',

  327.         );

  328.       }

  329.       componentDidMount() {

  330.         Scheduler.log(

  331.           'BrokenComponentDidMountErrorBoundary componentDidMount [!]',

  332.         );

  333.         throw new Error('Hello');

  334.       }

  335.       componentWillUnmount() {

  336.         Scheduler.log(

  337.           'BrokenComponentDidMountErrorBoundary componentWillUnmount',

  338.         );

  339.       }

  340.       static getDerivedStateFromError(error) {

  341.         Scheduler.log(

  342.           'BrokenComponentDidMountErrorBoundary static getDerivedStateFromError',

  343.         );

  344.         return {error};

  345.       }

  346.     };

  347. 

  348.     BrokenRenderErrorBoundary = class extends React.Component {

  349.       constructor(props) {

  350.         super(props);

  351.         this.state = {error: null};

  352.         Scheduler.log('BrokenRenderErrorBoundary constructor');

  353.       }

  354.       render() {

  355.         if (this.state.error) {

  356.           Scheduler.log('BrokenRenderErrorBoundary render error [!]');

  357.           throw new Error('Hello');

  358.         }

  359.         Scheduler.log('BrokenRenderErrorBoundary render success');

  360.         return <div>{this.props.children}</div>;

  361.       }

  362.       UNSAFE_componentWillMount() {

  363.         Scheduler.log('BrokenRenderErrorBoundary componentWillMount');

  364.       }

  365.       componentDidMount() {

  366.         Scheduler.log('BrokenRenderErrorBoundary componentDidMount');

  367.       }

  368.       componentWillUnmount() {

  369.         Scheduler.log('BrokenRenderErrorBoundary componentWillUnmount');

  370.       }

  371.       static getDerivedStateFromError(error) {

  372.         Scheduler.log(

  373.           'BrokenRenderErrorBoundary static getDerivedStateFromError',

  374.         );

  375.         return {error};

  376.       }

  377.     };

  378. 

  379.     BrokenRender = class extends React.Component {

  380.       constructor(props) {

  381.         super(props);

  382.         Scheduler.log('BrokenRender constructor');

  383.       }

  384.       render() {

  385.         Scheduler.log('BrokenRender render [!]');

  386.         throw new Error('Hello');

  387.       }

  388.       UNSAFE_componentWillMount() {

  389.         Scheduler.log('BrokenRender componentWillMount');

  390.       }

  391.       componentDidMount() {

  392.         Scheduler.log('BrokenRender componentDidMount');

  393.       }

  394.       UNSAFE_componentWillReceiveProps() {

  395.         Scheduler.log('BrokenRender componentWillReceiveProps');

  396.       }

  397.       UNSAFE_componentWillUpdate() {

  398.         Scheduler.log('BrokenRender componentWillUpdate');

  399.       }

  400.       componentDidUpdate() {

  401.         Scheduler.log('BrokenRender componentDidUpdate');

  402.       }

  403.       componentWillUnmount() {

  404.         Scheduler.log('BrokenRender componentWillUnmount');

  405.       }

  406.     };

  407. 

  408.     BrokenUseEffect = ({children}) => {

  409.       Scheduler.log('BrokenUseEffect render');

  410. 

  411.       React.useEffect(() => {

  412.         Scheduler.log('BrokenUseEffect useEffect [!]');

  413.         throw new Error('Hello');

  414.       });

  415. 

  416.       return children;

  417.     };

  418. 

  419.     BrokenUseLayoutEffect = ({children}) => {

  420.       Scheduler.log('BrokenUseLayoutEffect render');

  421. 

  422.       React.useLayoutEffect(() => {

  423.         Scheduler.log('BrokenUseLayoutEffect useLayoutEffect [!]');

  424.         throw new Error('Hello');

  425.       });

  426. 

  427.       return children;

  428.     };

  429. 

  430.     NoopErrorBoundary = class extends React.Component {

  431.       constructor(props) {

  432.         super(props);

  433.         Scheduler.log('NoopErrorBoundary constructor');

  434.       }

  435.       render() {

  436.         Scheduler.log('NoopErrorBoundary render');

  437.         return <BrokenRender />;

  438.       }

  439.       UNSAFE_componentWillMount() {

  440.         Scheduler.log('NoopErrorBoundary componentWillMount');

  441.       }

  442.       componentDidMount() {

  443.         Scheduler.log('NoopErrorBoundary componentDidMount');

  444.       }

  445.       componentWillUnmount() {

  446.         Scheduler.log('NoopErrorBoundary componentWillUnmount');

  447.       }

  448.       static getDerivedStateFromError() {

  449.         Scheduler.log('NoopErrorBoundary static getDerivedStateFromError');

  450.       }

  451.     };

  452. 

  453.     Normal = class extends React.Component {

  454.       static defaultProps = {

  455.         logName: 'Normal',

  456.       };

  457.       constructor(props) {

  458.         super(props);

  459.         Scheduler.log(`${this.props.logName} constructor`);

  460.       }

  461.       render() {

  462.         Scheduler.log(`${this.props.logName} render`);

  463.         return <div>{this.props.children}</div>;

  464.       }

  465.       UNSAFE_componentWillMount() {

  466.         Scheduler.log(`${this.props.logName} componentWillMount`);

  467.       }

  468.       componentDidMount() {

  469.         Scheduler.log(`${this.props.logName} componentDidMount`);

  470.       }

  471.       UNSAFE_componentWillReceiveProps() {

  472.         Scheduler.log(`${this.props.logName} componentWillReceiveProps`);

  473.       }

  474.       UNSAFE_componentWillUpdate() {

  475.         Scheduler.log(`${this.props.logName} componentWillUpdate`);

  476.       }

  477.       componentDidUpdate() {

  478.         Scheduler.log(`${this.props.logName} componentDidUpdate`);

  479.       }

  480.       componentWillUnmount() {

  481.         Scheduler.log(`${this.props.logName} componentWillUnmount`);

  482.       }

  483.     };

  484. 

  485.     ErrorBoundary = class extends React.Component {

  486.       constructor(props) {

  487.         super(props);

  488.         this.state = {error: null};

  489.         Scheduler.log(`${this.props.logName} constructor`);

  490.       }

  491.       render() {

  492.         if (this.state.error && !this.props.forceRetry) {

  493.           Scheduler.log(`${this.props.logName} render error`);

  494.           return this.props.renderError(this.state.error, this.props);

  495.         }

  496.         Scheduler.log(`${this.props.logName} render success`);

  497.         return <div>{this.props.children}</div>;

  498.       }

  499.       static getDerivedStateFromError(error) {

  500.         Scheduler.log('ErrorBoundary static getDerivedStateFromError');

  501.         return {error};

  502.       }

  503.       UNSAFE_componentWillMount() {

  504.         Scheduler.log(`${this.props.logName} componentWillMount`);

  505.       }

  506.       componentDidMount() {

  507.         Scheduler.log(`${this.props.logName} componentDidMount`);

  508.       }

  509.       UNSAFE_componentWillReceiveProps() {

  510.         Scheduler.log(`${this.props.logName} componentWillReceiveProps`);

  511.       }

  512.       UNSAFE_componentWillUpdate() {

  513.         Scheduler.log(`${this.props.logName} componentWillUpdate`);

  514.       }

  515.       componentDidUpdate() {

  516.         Scheduler.log(`${this.props.logName} componentDidUpdate`);

  517.       }

  518.       componentWillUnmount() {

  519.         Scheduler.log(`${this.props.logName} componentWillUnmount`);

  520.       }

  521.     };

  522.     ErrorBoundary.defaultProps = {

  523.       logName: 'ErrorBoundary',

  524.       renderError(error, props) {

  525.         return (

  526.           <div ref={props.errorMessageRef}>

  527.             Caught an error: {error.message}.

  528.           </div>

  529.         );

  530.       },

  531.     };

  532. 

  533.     RetryErrorBoundary = class extends React.Component {

  534.       constructor(props) {

  535.         super(props);

  536.         Scheduler.log('RetryErrorBoundary constructor');

  537.       }

  538.       render() {

  539.         Scheduler.log('RetryErrorBoundary render');

  540.         return <BrokenRender />;

  541.       }

  542.       UNSAFE_componentWillMount() {

  543.         Scheduler.log('RetryErrorBoundary componentWillMount');

  544.       }

  545.       componentDidMount() {

  546.         Scheduler.log('RetryErrorBoundary componentDidMount');

  547.       }

  548.       componentWillUnmount() {

  549.         Scheduler.log('RetryErrorBoundary componentWillUnmount');

  550.       }

  551.       static getDerivedStateFromError(error) {

  552.         Scheduler.log('RetryErrorBoundary static getDerivedStateFromError [!]');

  553.         // In Fiber, calling setState() (and failing) is treated as a rethrow.

  554.         return {};

  555.       }

  556.     };

  557. 

  558.     ErrorMessage = class extends React.Component {

  559.       constructor(props) {

  560.         super(props);

  561.         Scheduler.log('ErrorMessage constructor');

  562.       }

  563.       UNSAFE_componentWillMount() {

  564.         Scheduler.log('ErrorMessage componentWillMount');

  565.       }

  566.       componentDidMount() {

  567.         Scheduler.log('ErrorMessage componentDidMount');

  568.       }

  569.       componentWillUnmount() {

  570.         Scheduler.log('ErrorMessage componentWillUnmount');

  571.       }

  572.       render() {

  573.         Scheduler.log('ErrorMessage render');

  574.         return <div>Caught an error: {this.props.message}.</div>;

  575.       }

  576.     };

  577.   });

  578. 

  579.   it('does not swallow exceptions on mounting without boundaries', () => {

  580.     let container = document.createElement('div');

  581.     expect(() => {

  582.       ReactDOM.render(<BrokenRender />, container);

  583.     }).toThrow('Hello');

  584. 

  585.     container = document.createElement('div');

  586.     expect(() => {

  587.       ReactDOM.render(<BrokenComponentWillMount />, container);

  588.     }).toThrow('Hello');

  589. 

  590.     container = document.createElement('div');

  591.     expect(() => {

  592.       ReactDOM.render(<BrokenComponentDidMount />, container);

  593.     }).toThrow('Hello');

  594.   });

  595. 

  596.   it('does not swallow exceptions on updating without boundaries', () => {

  597.     let container = document.createElement('div');

  598.     ReactDOM.render(<BrokenComponentWillUpdate />, container);

  599.     expect(() => {

  600.       ReactDOM.render(<BrokenComponentWillUpdate />, container);

  601.     }).toThrow('Hello');

  602. 

  603.     container = document.createElement('div');

  604.     ReactDOM.render(<BrokenComponentWillReceiveProps />, container);

  605.     expect(() => {

  606.       ReactDOM.render(<BrokenComponentWillReceiveProps />, container);

  607.     }).toThrow('Hello');

  608. 

  609.     container = document.createElement('div');

  610.     ReactDOM.render(<BrokenComponentDidUpdate />, container);

  611.     expect(() => {

  612.       ReactDOM.render(<BrokenComponentDidUpdate />, container);

  613.     }).toThrow('Hello');

  614.   });

  615. 

  616.   it('does not swallow exceptions on unmounting without boundaries', () => {

  617.     const container = document.createElement('div');

  618.     ReactDOM.render(<BrokenComponentWillUnmount />, container);

  619.     expect(() => {

  620.       ReactDOM.unmountComponentAtNode(container);

  621.     }).toThrow('Hello');

  622.   });

  623. 

  624.   it('prevents errors from leaking into other roots', () => {

  625.     const container1 = document.createElement('div');

  626.     const container2 = document.createElement('div');

  627.     const container3 = document.createElement('div');

  628. 

  629.     ReactDOM.render(<span>Before 1</span>, container1);

  630.     expect(() => {

  631.       ReactDOM.render(<BrokenRender />, container2);

  632.     }).toThrow('Hello');

  633.     ReactDOM.render(

  634.       <ErrorBoundary>

  635.         <BrokenRender />

  636.       </ErrorBoundary>,

  637.       container3,

  638.     );

  639.     expect(container1.firstChild.textContent).toBe('Before 1');

  640.     expect(container2.firstChild).toBe(null);

  641.     expect(container3.firstChild.textContent).toBe('Caught an error: Hello.');

  642. 

  643.     ReactDOM.render(<span>After 1</span>, container1);

  644.     ReactDOM.render(<span>After 2</span>, container2);

  645.     ReactDOM.render(

  646.       <ErrorBoundary forceRetry={true}>After 3</ErrorBoundary>,

  647.       container3,

  648.     );

  649.     expect(container1.firstChild.textContent).toBe('After 1');

  650.     expect(container2.firstChild.textContent).toBe('After 2');

  651.     expect(container3.firstChild.textContent).toBe('After 3');

  652. 

  653.     ReactDOM.unmountComponentAtNode(container1);

  654.     ReactDOM.unmountComponentAtNode(container2);

  655.     ReactDOM.unmountComponentAtNode(container3);

  656.     expect(container1.firstChild).toBe(null);

  657.     expect(container2.firstChild).toBe(null);

  658.     expect(container3.firstChild).toBe(null);

  659.   });

  660. 

  661.   it('logs a single error when using error boundary', () => {

  662.     const container = document.createElement('div');

  663.     spyOnDev(console, 'error');

  664.     ReactDOM.render(

  665.       <ErrorBoundary>

  666.         <BrokenRender />

  667.       </ErrorBoundary>,

  668.       container,

  669.     );

  670.     if (__DEV__) {

  671.       expect(console.error).toHaveBeenCalledTimes(2);

  672.       expect(console.error.mock.calls[0][0]).toContain(

  673.         'ReactDOM.render is no longer supported',

  674.       );

  675.       expect(console.error.mock.calls[1][0]).toContain(

  676.         'The above error occurred in the <BrokenRender> component:',

  677.       );

  678.     }

  679. 

  680.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  681.     assertLog([

  682.       'ErrorBoundary constructor',

  683.       'ErrorBoundary componentWillMount',

  684.       'ErrorBoundary render success',

  685.       'BrokenRender constructor',

  686.       'BrokenRender componentWillMount',

  687.       'BrokenRender render [!]',

  688.       // Catch and render an error message

  689.       'ErrorBoundary static getDerivedStateFromError',

  690.       'ErrorBoundary componentWillMount',

  691.       'ErrorBoundary render error',

  692.       'ErrorBoundary componentDidMount',

  693.     ]);

  694. 

  695.     ReactDOM.unmountComponentAtNode(container);

  696.     assertLog(['ErrorBoundary componentWillUnmount']);

  697.   });

  698. 

  699.   it('renders an error state if child throws in render', () => {

  700.     const container = document.createElement('div');

  701.     ReactDOM.render(

  702.       <ErrorBoundary>

  703.         <BrokenRender />

  704.       </ErrorBoundary>,

  705.       container,

  706.     );

  707.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  708.     assertLog([

  709.       'ErrorBoundary constructor',

  710.       'ErrorBoundary componentWillMount',

  711.       'ErrorBoundary render success',

  712.       'BrokenRender constructor',

  713.       'BrokenRender componentWillMount',

  714.       'BrokenRender render [!]',

  715.       // Catch and render an error message

  716.       'ErrorBoundary static getDerivedStateFromError',

  717.       'ErrorBoundary componentWillMount',

  718.       'ErrorBoundary render error',

  719.       'ErrorBoundary componentDidMount',

  720.     ]);

  721. 

  722.     ReactDOM.unmountComponentAtNode(container);

  723.     assertLog(['ErrorBoundary componentWillUnmount']);

  724.   });

  725. 

  726.   it('renders an error state if child throws in constructor', () => {

  727.     const container = document.createElement('div');

  728.     ReactDOM.render(

  729.       <ErrorBoundary>

  730.         <BrokenConstructor />

  731.       </ErrorBoundary>,

  732.       container,

  733.     );

  734.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  735.     assertLog([

  736.       'ErrorBoundary constructor',

  737.       'ErrorBoundary componentWillMount',

  738.       'ErrorBoundary render success',

  739.       'BrokenConstructor constructor [!]',

  740.       // Catch and render an error message

  741.       'ErrorBoundary static getDerivedStateFromError',

  742.       'ErrorBoundary componentWillMount',

  743.       'ErrorBoundary render error',

  744.       'ErrorBoundary componentDidMount',

  745.     ]);

  746. 

  747.     ReactDOM.unmountComponentAtNode(container);

  748.     assertLog(['ErrorBoundary componentWillUnmount']);

  749.   });

  750. 

  751.   it('renders an error state if child throws in componentWillMount', () => {

  752.     const container = document.createElement('div');

  753.     ReactDOM.render(

  754.       <ErrorBoundary>

  755.         <BrokenComponentWillMount />

  756.       </ErrorBoundary>,

  757.       container,

  758.     );

  759.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  760.     assertLog([

  761.       'ErrorBoundary constructor',

  762.       'ErrorBoundary componentWillMount',

  763.       'ErrorBoundary render success',

  764.       'BrokenComponentWillMount constructor',

  765.       'BrokenComponentWillMount componentWillMount [!]',

  766.       // Catch and render an error message

  767.       'ErrorBoundary static getDerivedStateFromError',

  768.       'ErrorBoundary componentWillMount',

  769.       'ErrorBoundary render error',

  770.       'ErrorBoundary componentDidMount',

  771.     ]);

  772. 

  773.     ReactDOM.unmountComponentAtNode(container);

  774.     assertLog(['ErrorBoundary componentWillUnmount']);

  775.   });

  776. 

  777.   // @gate !disableLegacyContext || !__DEV__

  778.   it('renders an error state if context provider throws in componentWillMount', () => {

  779.     class BrokenComponentWillMountWithContext extends React.Component {

  780.       static childContextTypes = {foo: PropTypes.number};

  781.       getChildContext() {

  782.         return {foo: 42};

  783.       }

  784.       render() {

  785.         return <div>{this.props.children}</div>;

  786.       }

  787.       UNSAFE_componentWillMount() {

  788.         throw new Error('Hello');

  789.       }

  790.     }

  791. 

  792.     const container = document.createElement('div');

  793.     ReactDOM.render(

  794.       <ErrorBoundary>

  795.         <BrokenComponentWillMountWithContext />

  796.       </ErrorBoundary>,

  797.       container,

  798.     );

  799.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  800.   });

  801. 

  802.   // @gate !disableModulePatternComponents

  803.   // @gate !disableLegacyContext

  804.   it('renders an error state if module-style context provider throws in componentWillMount', () => {

  805.     function BrokenComponentWillMountWithContext() {

  806.       return {

  807.         getChildContext() {

  808.           return {foo: 42};

  809.         },

  810.         render() {

  811.           return <div>{this.props.children}</div>;

  812.         },

  813.         UNSAFE_componentWillMount() {

  814.           throw new Error('Hello');

  815.         },

  816.       };

  817.     }

  818.     BrokenComponentWillMountWithContext.childContextTypes = {

  819.       foo: PropTypes.number,

  820.     };

  821. 

  822.     const container = document.createElement('div');

  823.     expect(() =>

  824.       ReactDOM.render(

  825.         <ErrorBoundary>

  826.           <BrokenComponentWillMountWithContext />

  827.         </ErrorBoundary>,

  828.         container,

  829.       ),

  830.     ).toErrorDev(

  831.       'Warning: The <BrokenComponentWillMountWithContext /> component appears to be a function component that ' +

  832.         'returns a class instance. ' +

  833.         'Change BrokenComponentWillMountWithContext to a class that extends React.Component instead. ' +

  834.         "If you can't use a class try assigning the prototype on the function as a workaround. " +

  835.         '`BrokenComponentWillMountWithContext.prototype = React.Component.prototype`. ' +

  836.         "Don't use an arrow function since it cannot be called with `new` by React.",

  837.     );

  838. 

  839.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  840.   });

  841. 

  842.   it('mounts the error message if mounting fails', () => {

  843.     function renderError(error) {

  844.       return <ErrorMessage message={error.message} />;

  845.     }

  846. 

  847.     const container = document.createElement('div');

  848.     ReactDOM.render(

  849.       <ErrorBoundary renderError={renderError}>

  850.         <BrokenRender />

  851.       </ErrorBoundary>,

  852.       container,

  853.     );

  854.     assertLog([

  855.       'ErrorBoundary constructor',

  856.       'ErrorBoundary componentWillMount',

  857.       'ErrorBoundary render success',

  858.       'BrokenRender constructor',

  859.       'BrokenRender componentWillMount',

  860.       'BrokenRender render [!]',

  861.       'ErrorBoundary static getDerivedStateFromError',

  862.       'ErrorBoundary componentWillMount',

  863.       'ErrorBoundary render error',

  864.       'ErrorMessage constructor',

  865.       'ErrorMessage componentWillMount',

  866.       'ErrorMessage render',

  867.       'ErrorMessage componentDidMount',

  868.       'ErrorBoundary componentDidMount',

  869.     ]);

  870. 

  871.     ReactDOM.unmountComponentAtNode(container);

  872.     assertLog([

  873.       'ErrorBoundary componentWillUnmount',

  874.       'ErrorMessage componentWillUnmount',

  875.     ]);

  876.   });

  877. 

  878.   it('propagates errors on retry on mounting', () => {

  879.     const container = document.createElement('div');

  880.     ReactDOM.render(

  881.       <ErrorBoundary>

  882.         <RetryErrorBoundary>

  883.           <BrokenRender />

  884.         </RetryErrorBoundary>

  885.       </ErrorBoundary>,

  886.       container,

  887.     );

  888.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  889.     assertLog([

  890.       'ErrorBoundary constructor',

  891.       'ErrorBoundary componentWillMount',

  892.       'ErrorBoundary render success',

  893.       'RetryErrorBoundary constructor',

  894.       'RetryErrorBoundary componentWillMount',

  895.       'RetryErrorBoundary render',

  896.       'BrokenRender constructor',

  897.       'BrokenRender componentWillMount',

  898.       'BrokenRender render [!]',

  899.       // Retry

  900.       'RetryErrorBoundary static getDerivedStateFromError [!]',

  901.       'RetryErrorBoundary componentWillMount',

  902.       'RetryErrorBoundary render',

  903.       'BrokenRender constructor',

  904.       'BrokenRender componentWillMount',

  905.       'BrokenRender render [!]',

  906.       // This time, the error propagates to the higher boundary

  907.       'ErrorBoundary static getDerivedStateFromError',

  908.       'ErrorBoundary componentWillMount',

  909.       'ErrorBoundary render error',

  910.       'ErrorBoundary componentDidMount',

  911.     ]);

  912. 

  913.     ReactDOM.unmountComponentAtNode(container);

  914.     assertLog(['ErrorBoundary componentWillUnmount']);

  915.   });

  916. 

  917.   it('propagates errors inside boundary during componentWillMount', () => {

  918.     const container = document.createElement('div');

  919.     ReactDOM.render(

  920.       <ErrorBoundary>

  921.         <BrokenComponentWillMountErrorBoundary />

  922.       </ErrorBoundary>,

  923.       container,

  924.     );

  925.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  926.     assertLog([

  927.       'ErrorBoundary constructor',

  928.       'ErrorBoundary componentWillMount',

  929.       'ErrorBoundary render success',

  930.       'BrokenComponentWillMountErrorBoundary constructor',

  931.       'BrokenComponentWillMountErrorBoundary componentWillMount [!]',

  932.       // The error propagates to the higher boundary

  933.       'ErrorBoundary static getDerivedStateFromError',

  934.       'ErrorBoundary componentWillMount',

  935.       'ErrorBoundary render error',

  936.       'ErrorBoundary componentDidMount',

  937.     ]);

  938. 

  939.     ReactDOM.unmountComponentAtNode(container);

  940.     assertLog(['ErrorBoundary componentWillUnmount']);

  941.   });

  942. 

  943.   it('propagates errors inside boundary while rendering error state', () => {

  944.     const container = document.createElement('div');

  945.     ReactDOM.render(

  946.       <ErrorBoundary>

  947.         <BrokenRenderErrorBoundary>

  948.           <BrokenRender />

  949.         </BrokenRenderErrorBoundary>

  950.       </ErrorBoundary>,

  951.       container,

  952.     );

  953.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  954.     assertLog([

  955.       'ErrorBoundary constructor',

  956.       'ErrorBoundary componentWillMount',

  957.       'ErrorBoundary render success',

  958.       'BrokenRenderErrorBoundary constructor',

  959.       'BrokenRenderErrorBoundary componentWillMount',

  960.       'BrokenRenderErrorBoundary render success',

  961.       'BrokenRender constructor',

  962.       'BrokenRender componentWillMount',

  963.       'BrokenRender render [!]',

  964.       // Attempt to handle the error

  965.       'BrokenRenderErrorBoundary static getDerivedStateFromError',

  966.       'BrokenRenderErrorBoundary componentWillMount',

  967.       'BrokenRenderErrorBoundary render error [!]',

  968.       // Attempt to handle the error again

  969.       'ErrorBoundary static getDerivedStateFromError',

  970.       'ErrorBoundary componentWillMount',

  971.       'ErrorBoundary render error',

  972.       'ErrorBoundary componentDidMount',

  973.     ]);

  974. 

  975.     ReactDOM.unmountComponentAtNode(container);

  976.     assertLog(['ErrorBoundary componentWillUnmount']);

  977.   });

  978. 

  979.   it('does not call componentWillUnmount when aborting initial mount', () => {

  980.     const container = document.createElement('div');

  981.     ReactDOM.render(

  982.       <ErrorBoundary>

  983.         <Normal />

  984.         <BrokenRender />

  985.         <Normal />

  986.       </ErrorBoundary>,

  987.       container,

  988.     );

  989.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  990.     assertLog([

  991.       'ErrorBoundary constructor',

  992.       'ErrorBoundary componentWillMount',

  993.       'ErrorBoundary render success',

  994.       // Render first child

  995.       'Normal constructor',

  996.       'Normal componentWillMount',

  997.       'Normal render',

  998.       // Render second child (it throws)

  999.       'BrokenRender constructor',

  1000.       'BrokenRender componentWillMount',

  1001.       'BrokenRender render [!]',

  1002.       // Skip the remaining siblings

  1003.       // Handle the error

  1004.       'ErrorBoundary static getDerivedStateFromError',

  1005.       'ErrorBoundary componentWillMount',

  1006.       'ErrorBoundary render error',

  1007.       'ErrorBoundary componentDidMount',

  1008.     ]);

  1009. 

  1010.     ReactDOM.unmountComponentAtNode(container);

  1011.     assertLog(['ErrorBoundary componentWillUnmount']);

  1012.   });

  1013. 

  1014.   it('resets callback refs if mounting aborts', () => {

  1015.     function childRef(x) {

  1016.       Scheduler.log('Child ref is set to ' + x);

  1017.     }

  1018.     function errorMessageRef(x) {

  1019.       Scheduler.log('Error message ref is set to ' + x);

  1020.     }

  1021. 

  1022.     const container = document.createElement('div');

  1023.     ReactDOM.render(

  1024.       <ErrorBoundary errorMessageRef={errorMessageRef}>

  1025.         <div ref={childRef} />

  1026.         <BrokenRender />

  1027.       </ErrorBoundary>,

  1028.       container,

  1029.     );

  1030.     expect(container.textContent).toBe('Caught an error: Hello.');

  1031.     assertLog([

  1032.       'ErrorBoundary constructor',

  1033.       'ErrorBoundary componentWillMount',

  1034.       'ErrorBoundary render success',

  1035.       'BrokenRender constructor',

  1036.       'BrokenRender componentWillMount',

  1037.       'BrokenRender render [!]',

  1038.       // Handle the error

  1039.       'ErrorBoundary static getDerivedStateFromError',

  1040.       'ErrorBoundary componentWillMount',

  1041.       'ErrorBoundary render error',

  1042.       'Error message ref is set to [object HTMLDivElement]',

  1043.       'ErrorBoundary componentDidMount',

  1044.     ]);

  1045. 

  1046.     ReactDOM.unmountComponentAtNode(container);

  1047.     assertLog([

  1048.       'ErrorBoundary componentWillUnmount',

  1049.       'Error message ref is set to null',

  1050.     ]);

  1051.   });

  1052. 

  1053.   it('resets object refs if mounting aborts', () => {

  1054.     const childRef = React.createRef();

  1055.     const errorMessageRef = React.createRef();

  1056. 

  1057.     const container = document.createElement('div');

  1058.     ReactDOM.render(

  1059.       <ErrorBoundary errorMessageRef={errorMessageRef}>

  1060.         <div ref={childRef} />

  1061.         <BrokenRender />

  1062.       </ErrorBoundary>,

  1063.       container,

  1064.     );

  1065.     expect(container.textContent).toBe('Caught an error: Hello.');

  1066.     assertLog([

  1067.       'ErrorBoundary constructor',

  1068.       'ErrorBoundary componentWillMount',

  1069.       'ErrorBoundary render success',

  1070.       'BrokenRender constructor',

  1071.       'BrokenRender componentWillMount',

  1072.       'BrokenRender render [!]',

  1073.       // Handle the error

  1074.       'ErrorBoundary static getDerivedStateFromError',

  1075.       'ErrorBoundary componentWillMount',

  1076.       'ErrorBoundary render error',

  1077.       'ErrorBoundary componentDidMount',

  1078.     ]);

  1079.     expect(errorMessageRef.current.toString()).toEqual(

  1080.       '[object HTMLDivElement]',

  1081.     );

  1082. 

  1083.     ReactDOM.unmountComponentAtNode(container);

  1084.     assertLog(['ErrorBoundary componentWillUnmount']);

  1085.     expect(errorMessageRef.current).toEqual(null);

  1086.   });

  1087. 

  1088.   it('successfully mounts if no error occurs', () => {

  1089.     const container = document.createElement('div');

  1090.     ReactDOM.render(

  1091.       <ErrorBoundary>

  1092.         <div>Mounted successfully.</div>

  1093.       </ErrorBoundary>,

  1094.       container,

  1095.     );

  1096.     expect(container.firstChild.textContent).toBe('Mounted successfully.');

  1097.     assertLog([

  1098.       'ErrorBoundary constructor',

  1099.       'ErrorBoundary componentWillMount',

  1100.       'ErrorBoundary render success',

  1101.       'ErrorBoundary componentDidMount',

  1102.     ]);

  1103. 

  1104.     ReactDOM.unmountComponentAtNode(container);

  1105.     assertLog(['ErrorBoundary componentWillUnmount']);

  1106.   });

  1107. 

  1108.   it('catches if child throws in constructor during update', () => {

  1109.     const container = document.createElement('div');

  1110.     ReactDOM.render(

  1111.       <ErrorBoundary>

  1112.         <Normal />

  1113.       </ErrorBoundary>,

  1114.       container,

  1115.     );

  1116.     Scheduler.unstable_clearLog();

  1117.     ReactDOM.render(

  1118.       <ErrorBoundary>

  1119.         <Normal />

  1120.         <Normal logName="Normal2" />

  1121.         <BrokenConstructor />

  1122.       </ErrorBoundary>,

  1123.       container,

  1124.     );

  1125.     expect(container.textContent).toBe('Caught an error: Hello.');

  1126.     assertLog([

  1127.       'ErrorBoundary componentWillReceiveProps',

  1128.       'ErrorBoundary componentWillUpdate',

  1129.       'ErrorBoundary render success',

  1130.       'Normal componentWillReceiveProps',

  1131.       'Normal componentWillUpdate',

  1132.       'Normal render',

  1133.       // Normal2 will attempt to mount:

  1134.       'Normal2 constructor',

  1135.       'Normal2 componentWillMount',

  1136.       'Normal2 render',

  1137.       // BrokenConstructor will abort rendering:

  1138.       'BrokenConstructor constructor [!]',

  1139.       // Handle the error

  1140.       'ErrorBoundary static getDerivedStateFromError',

  1141.       // Render the error message

  1142.       'ErrorBoundary componentWillUpdate',

  1143.       'ErrorBoundary render error',

  1144.       'Normal componentWillUnmount',

  1145.       'ErrorBoundary componentDidUpdate',

  1146.     ]);

  1147. 

  1148.     ReactDOM.unmountComponentAtNode(container);

  1149.     assertLog(['ErrorBoundary componentWillUnmount']);

  1150.   });

  1151. 

  1152.   it('catches if child throws in componentWillMount during update', () => {

  1153.     const container = document.createElement('div');

  1154.     ReactDOM.render(

  1155.       <ErrorBoundary>

  1156.         <Normal />

  1157.       </ErrorBoundary>,

  1158.       container,

  1159.     );

  1160. 

  1161.     Scheduler.unstable_clearLog();

  1162.     ReactDOM.render(

  1163.       <ErrorBoundary>

  1164.         <Normal />

  1165.         <Normal logName="Normal2" />

  1166.         <BrokenComponentWillMount />

  1167.       </ErrorBoundary>,

  1168.       container,

  1169.     );

  1170.     expect(container.textContent).toBe('Caught an error: Hello.');

  1171.     assertLog([

  1172.       'ErrorBoundary componentWillReceiveProps',

  1173.       'ErrorBoundary componentWillUpdate',

  1174.       'ErrorBoundary render success',

  1175.       'Normal componentWillReceiveProps',

  1176.       'Normal componentWillUpdate',

  1177.       'Normal render',

  1178.       // Normal2 will attempt to mount:

  1179.       'Normal2 constructor',

  1180.       'Normal2 componentWillMount',

  1181.       'Normal2 render',

  1182.       // BrokenComponentWillMount will abort rendering:

  1183.       'BrokenComponentWillMount constructor',

  1184.       'BrokenComponentWillMount componentWillMount [!]',

  1185.       // Handle the error

  1186.       'ErrorBoundary static getDerivedStateFromError',

  1187.       // Render the error message

  1188.       'ErrorBoundary componentWillUpdate',

  1189.       'ErrorBoundary render error',

  1190.       'Normal componentWillUnmount',

  1191.       'ErrorBoundary componentDidUpdate',

  1192.     ]);

  1193. 

  1194.     ReactDOM.unmountComponentAtNode(container);

  1195.     assertLog(['ErrorBoundary componentWillUnmount']);

  1196.   });

  1197. 

  1198.   it('catches if child throws in componentWillReceiveProps during update', () => {

  1199.     const container = document.createElement('div');

  1200.     ReactDOM.render(

  1201.       <ErrorBoundary>

  1202.         <Normal />

  1203.         <BrokenComponentWillReceiveProps />

  1204.       </ErrorBoundary>,

  1205.       container,

  1206.     );

  1207. 

  1208.     Scheduler.unstable_clearLog();

  1209.     ReactDOM.render(

  1210.       <ErrorBoundary>

  1211.         <Normal />

  1212.         <BrokenComponentWillReceiveProps />

  1213.       </ErrorBoundary>,

  1214.       container,

  1215.     );

  1216.     expect(container.textContent).toBe('Caught an error: Hello.');

  1217.     assertLog([

  1218.       'ErrorBoundary componentWillReceiveProps',

  1219.       'ErrorBoundary componentWillUpdate',

  1220.       'ErrorBoundary render success',

  1221.       'Normal componentWillReceiveProps',

  1222.       'Normal componentWillUpdate',

  1223.       'Normal render',

  1224.       // BrokenComponentWillReceiveProps will abort rendering:

  1225.       'BrokenComponentWillReceiveProps componentWillReceiveProps [!]',

  1226.       // Handle the error

  1227.       'ErrorBoundary static getDerivedStateFromError',

  1228.       // Render the error message

  1229.       'ErrorBoundary componentWillUpdate',

  1230.       'ErrorBoundary render error',

  1231.       'Normal componentWillUnmount',

  1232.       'BrokenComponentWillReceiveProps componentWillUnmount',

  1233.       'ErrorBoundary componentDidUpdate',

  1234.     ]);

  1235. 

  1236.     ReactDOM.unmountComponentAtNode(container);

  1237.     assertLog(['ErrorBoundary componentWillUnmount']);

  1238.   });

  1239. 

  1240.   it('catches if child throws in componentWillUpdate during update', () => {

  1241.     const container = document.createElement('div');

  1242.     ReactDOM.render(

  1243.       <ErrorBoundary>

  1244.         <Normal />

  1245.         <BrokenComponentWillUpdate />

  1246.       </ErrorBoundary>,

  1247.       container,

  1248.     );

  1249. 

  1250.     Scheduler.unstable_clearLog();

  1251.     ReactDOM.render(

  1252.       <ErrorBoundary>

  1253.         <Normal />

  1254.         <BrokenComponentWillUpdate />

  1255.       </ErrorBoundary>,

  1256.       container,

  1257.     );

  1258.     expect(container.textContent).toBe('Caught an error: Hello.');

  1259.     assertLog([

  1260.       'ErrorBoundary componentWillReceiveProps',

  1261.       'ErrorBoundary componentWillUpdate',

  1262.       'ErrorBoundary render success',

  1263.       'Normal componentWillReceiveProps',

  1264.       'Normal componentWillUpdate',

  1265.       'Normal render',

  1266.       // BrokenComponentWillUpdate will abort rendering:

  1267.       'BrokenComponentWillUpdate componentWillReceiveProps',

  1268.       'BrokenComponentWillUpdate componentWillUpdate [!]',

  1269.       // Handle the error

  1270.       'ErrorBoundary static getDerivedStateFromError',

  1271.       'ErrorBoundary componentWillUpdate',

  1272.       'ErrorBoundary render error',

  1273.       'Normal componentWillUnmount',

  1274.       'BrokenComponentWillUpdate componentWillUnmount',

  1275.       'ErrorBoundary componentDidUpdate',

  1276.     ]);

  1277. 

  1278.     ReactDOM.unmountComponentAtNode(container);

  1279.     assertLog(['ErrorBoundary componentWillUnmount']);

  1280.   });

  1281. 

  1282.   it('catches if child throws in render during update', () => {

  1283.     const container = document.createElement('div');

  1284.     ReactDOM.render(

  1285.       <ErrorBoundary>

  1286.         <Normal />

  1287.       </ErrorBoundary>,

  1288.       container,

  1289.     );

  1290. 

  1291.     Scheduler.unstable_clearLog();

  1292.     ReactDOM.render(

  1293.       <ErrorBoundary>

  1294.         <Normal />

  1295.         <Normal logName="Normal2" />

  1296.         <BrokenRender />

  1297.       </ErrorBoundary>,

  1298.       container,

  1299.     );

  1300.     expect(container.textContent).toBe('Caught an error: Hello.');

  1301.     assertLog([

  1302.       'ErrorBoundary componentWillReceiveProps',

  1303.       'ErrorBoundary componentWillUpdate',

  1304.       'ErrorBoundary render success',

  1305.       'Normal componentWillReceiveProps',

  1306.       'Normal componentWillUpdate',

  1307.       'Normal render',

  1308.       // Normal2 will attempt to mount:

  1309.       'Normal2 constructor',

  1310.       'Normal2 componentWillMount',

  1311.       'Normal2 render',

  1312.       // BrokenRender will abort rendering:

  1313.       'BrokenRender constructor',

  1314.       'BrokenRender componentWillMount',

  1315.       'BrokenRender render [!]',

  1316.       // Handle the error

  1317.       'ErrorBoundary static getDerivedStateFromError',

  1318.       'ErrorBoundary componentWillUpdate',

  1319.       'ErrorBoundary render error',

  1320.       'Normal componentWillUnmount',

  1321.       'ErrorBoundary componentDidUpdate',

  1322.     ]);

  1323. 

  1324.     ReactDOM.unmountComponentAtNode(container);

  1325.     assertLog(['ErrorBoundary componentWillUnmount']);

  1326.   });

  1327. 

  1328.   it('keeps refs up-to-date during updates', () => {

  1329.     function child1Ref(x) {

  1330.       Scheduler.log('Child1 ref is set to ' + x);

  1331.     }

  1332.     function child2Ref(x) {

  1333.       Scheduler.log('Child2 ref is set to ' + x);

  1334.     }

  1335.     function errorMessageRef(x) {

  1336.       Scheduler.log('Error message ref is set to ' + x);

  1337.     }

  1338. 

  1339.     const container = document.createElement('div');

  1340.     ReactDOM.render(

  1341.       <ErrorBoundary errorMessageRef={errorMessageRef}>

  1342.         <div ref={child1Ref} />

  1343.       </ErrorBoundary>,

  1344.       container,

  1345.     );

  1346.     assertLog([

  1347.       'ErrorBoundary constructor',

  1348.       'ErrorBoundary componentWillMount',

  1349.       'ErrorBoundary render success',

  1350.       'Child1 ref is set to [object HTMLDivElement]',

  1351.       'ErrorBoundary componentDidMount',

  1352.     ]);

  1353. 

  1354.     ReactDOM.render(

  1355.       <ErrorBoundary errorMessageRef={errorMessageRef}>

  1356.         <div ref={child1Ref} />

  1357.         <div ref={child2Ref} />

  1358.         <BrokenRender />

  1359.       </ErrorBoundary>,

  1360.       container,

  1361.     );

  1362.     expect(container.textContent).toBe('Caught an error: Hello.');

  1363.     assertLog([

  1364.       'ErrorBoundary componentWillReceiveProps',

  1365.       'ErrorBoundary componentWillUpdate',

  1366.       'ErrorBoundary render success',

  1367.       // BrokenRender will abort rendering:

  1368.       'BrokenRender constructor',

  1369.       'BrokenRender componentWillMount',

  1370.       'BrokenRender render [!]',

  1371.       // Handle the error

  1372.       'ErrorBoundary static getDerivedStateFromError',

  1373.       'ErrorBoundary componentWillUpdate',

  1374.       'ErrorBoundary render error',

  1375.       // Update Child1 ref since Child1 has been unmounted

  1376.       // Child2 ref is never set because its mounting aborted

  1377.       'Child1 ref is set to null',

  1378.       'Error message ref is set to [object HTMLDivElement]',

  1379.       'ErrorBoundary componentDidUpdate',

  1380.     ]);

  1381. 

  1382.     ReactDOM.unmountComponentAtNode(container);

  1383.     assertLog([

  1384.       'ErrorBoundary componentWillUnmount',

  1385.       'Error message ref is set to null',

  1386.     ]);

  1387.   });

  1388. 

  1389.   it('recovers from componentWillUnmount errors on update', () => {

  1390.     const container = document.createElement('div');

  1391.     ReactDOM.render(

  1392.       <ErrorBoundary>

  1393.         <BrokenComponentWillUnmount />

  1394.         <BrokenComponentWillUnmount />

  1395.         <Normal />

  1396.       </ErrorBoundary>,

  1397.       container,

  1398.     );

  1399. 

  1400.     Scheduler.unstable_clearLog();

  1401.     ReactDOM.render(

  1402.       <ErrorBoundary>

  1403.         <BrokenComponentWillUnmount />

  1404.       </ErrorBoundary>,

  1405.       container,

  1406.     );

  1407.     expect(container.textContent).toBe('Caught an error: Hello.');

  1408.     assertLog([

  1409.       'ErrorBoundary componentWillReceiveProps',

  1410.       'ErrorBoundary componentWillUpdate',

  1411.       'ErrorBoundary render success',

  1412.       // Update existing child:

  1413.       'BrokenComponentWillUnmount componentWillReceiveProps',

  1414.       'BrokenComponentWillUnmount componentWillUpdate',

  1415.       'BrokenComponentWillUnmount render',

  1416.       // Unmounting throws:

  1417.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1418.       // Fiber proceeds with lifecycles despite errors

  1419.       'Normal componentWillUnmount',

  1420.       // The components have updated in this phase

  1421.       'BrokenComponentWillUnmount componentDidUpdate',

  1422.       'ErrorBoundary componentDidUpdate',

  1423.       // The initial render was aborted, so

  1424.       // Fiber retries from the root.

  1425.       'ErrorBoundary static getDerivedStateFromError',

  1426.       'ErrorBoundary componentWillUpdate',

  1427.       'ErrorBoundary render error',

  1428.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1429.       'ErrorBoundary componentDidUpdate',

  1430.       // The second willUnmount error should be captured and logged, too.

  1431.       'ErrorBoundary static getDerivedStateFromError',

  1432.       'ErrorBoundary componentWillUpdate',

  1433.       // Render an error now (stack will do it later)

  1434.       'ErrorBoundary render error',

  1435.       // Attempt to unmount previous child:

  1436.       // Done

  1437.       'ErrorBoundary componentDidUpdate',

  1438.     ]);

  1439. 

  1440.     ReactDOM.unmountComponentAtNode(container);

  1441.     assertLog(['ErrorBoundary componentWillUnmount']);

  1442.   });

  1443. 

  1444.   it('recovers from nested componentWillUnmount errors on update', () => {

  1445.     const container = document.createElement('div');

  1446.     ReactDOM.render(

  1447.       <ErrorBoundary>

  1448.         <Normal>

  1449.           <BrokenComponentWillUnmount />

  1450.         </Normal>

  1451.         <BrokenComponentWillUnmount />

  1452.       </ErrorBoundary>,

  1453.       container,

  1454.     );

  1455. 

  1456.     Scheduler.unstable_clearLog();

  1457.     ReactDOM.render(

  1458.       <ErrorBoundary>

  1459.         <Normal>

  1460.           <BrokenComponentWillUnmount />

  1461.         </Normal>

  1462.       </ErrorBoundary>,

  1463.       container,

  1464.     );

  1465.     expect(container.textContent).toBe('Caught an error: Hello.');

  1466.     assertLog([

  1467.       'ErrorBoundary componentWillReceiveProps',

  1468.       'ErrorBoundary componentWillUpdate',

  1469.       'ErrorBoundary render success',

  1470.       // Update existing children:

  1471.       'Normal componentWillReceiveProps',

  1472.       'Normal componentWillUpdate',

  1473.       'Normal render',

  1474.       'BrokenComponentWillUnmount componentWillReceiveProps',

  1475.       'BrokenComponentWillUnmount componentWillUpdate',

  1476.       'BrokenComponentWillUnmount render',

  1477.       // Unmounting throws:

  1478.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1479.       // Fiber proceeds with lifecycles despite errors

  1480.       'BrokenComponentWillUnmount componentDidUpdate',

  1481.       'Normal componentDidUpdate',

  1482.       'ErrorBoundary componentDidUpdate',

  1483.       // Now that commit phase is done, Fiber handles errors

  1484.       'ErrorBoundary static getDerivedStateFromError',

  1485.       'ErrorBoundary componentWillUpdate',

  1486.       'ErrorBoundary render error',

  1487.       'Normal componentWillUnmount',

  1488.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1489.       'ErrorBoundary componentDidUpdate',

  1490.       // The second willUnmount error should be captured and logged, too.

  1491.       'ErrorBoundary static getDerivedStateFromError',

  1492.       'ErrorBoundary componentWillUpdate',

  1493.       // Render an error now (stack will do it later)

  1494.       'ErrorBoundary render error',

  1495.       // Done

  1496.       'ErrorBoundary componentDidUpdate',

  1497.     ]);

  1498. 

  1499.     ReactDOM.unmountComponentAtNode(container);

  1500.     assertLog(['ErrorBoundary componentWillUnmount']);

  1501.   });

  1502. 

  1503.   it('picks the right boundary when handling unmounting errors', () => {

  1504.     function renderInnerError(error) {

  1505.       return <div>Caught an inner error: {error.message}.</div>;

  1506.     }

  1507.     function renderOuterError(error) {

  1508.       return <div>Caught an outer error: {error.message}.</div>;

  1509.     }

  1510. 

  1511.     const container = document.createElement('div');

  1512.     ReactDOM.render(

  1513.       <ErrorBoundary

  1514.         logName="OuterErrorBoundary"

  1515.         renderError={renderOuterError}>

  1516.         <ErrorBoundary

  1517.           logName="InnerErrorBoundary"

  1518.           renderError={renderInnerError}>

  1519.           <BrokenComponentWillUnmount />

  1520.         </ErrorBoundary>

  1521.       </ErrorBoundary>,

  1522.       container,

  1523.     );

  1524. 

  1525.     Scheduler.unstable_clearLog();

  1526.     ReactDOM.render(

  1527.       <ErrorBoundary

  1528.         logName="OuterErrorBoundary"

  1529.         renderError={renderOuterError}>

  1530.         <ErrorBoundary

  1531.           logName="InnerErrorBoundary"

  1532.           renderError={renderInnerError}

  1533.         />

  1534.       </ErrorBoundary>,

  1535.       container,

  1536.     );

  1537.     expect(container.textContent).toBe('Caught an inner error: Hello.');

  1538.     assertLog([

  1539.       // Update outer boundary

  1540.       'OuterErrorBoundary componentWillReceiveProps',

  1541.       'OuterErrorBoundary componentWillUpdate',

  1542.       'OuterErrorBoundary render success',

  1543.       // Update inner boundary

  1544.       'InnerErrorBoundary componentWillReceiveProps',

  1545.       'InnerErrorBoundary componentWillUpdate',

  1546.       'InnerErrorBoundary render success',

  1547.       // Try unmounting child

  1548.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1549.       // Now that commit phase is done, Fiber handles errors

  1550.       // Only inner boundary receives the error:

  1551.       'InnerErrorBoundary componentDidUpdate',

  1552.       'OuterErrorBoundary componentDidUpdate',

  1553.       'ErrorBoundary static getDerivedStateFromError',

  1554.       'InnerErrorBoundary componentWillUpdate',

  1555.       // Render an error now

  1556.       'InnerErrorBoundary render error',

  1557.       // In Fiber, this was a local update to the

  1558.       // inner boundary so only its hook fires

  1559.       'InnerErrorBoundary componentDidUpdate',

  1560.     ]);

  1561. 

  1562.     ReactDOM.unmountComponentAtNode(container);

  1563.     assertLog([

  1564.       'OuterErrorBoundary componentWillUnmount',

  1565.       'InnerErrorBoundary componentWillUnmount',

  1566.     ]);

  1567.   });

  1568. 

  1569.   it('can recover from error state', () => {

  1570.     const container = document.createElement('div');

  1571.     ReactDOM.render(

  1572.       <ErrorBoundary>

  1573.         <BrokenRender />

  1574.       </ErrorBoundary>,

  1575.       container,

  1576.     );

  1577. 

  1578.     ReactDOM.render(

  1579.       <ErrorBoundary>

  1580.         <Normal />

  1581.       </ErrorBoundary>,

  1582.       container,

  1583.     );

  1584.     // Error boundary doesn't retry by itself:

  1585.     expect(container.textContent).toBe('Caught an error: Hello.');

  1586. 

  1587.     // Force the success path:

  1588.     Scheduler.unstable_clearLog();

  1589.     ReactDOM.render(

  1590.       <ErrorBoundary forceRetry={true}>

  1591.         <Normal />

  1592.       </ErrorBoundary>,

  1593.       container,

  1594.     );

  1595.     expect(container.textContent).not.toContain('Caught an error');

  1596.     assertLog([

  1597.       'ErrorBoundary componentWillReceiveProps',

  1598.       'ErrorBoundary componentWillUpdate',

  1599.       'ErrorBoundary render success',

  1600.       // Mount children:

  1601.       'Normal constructor',

  1602.       'Normal componentWillMount',

  1603.       'Normal render',

  1604.       // Finalize updates:

  1605.       'Normal componentDidMount',

  1606.       'ErrorBoundary componentDidUpdate',

  1607.     ]);

  1608. 

  1609.     ReactDOM.unmountComponentAtNode(container);

  1610.     assertLog([

  1611.       'ErrorBoundary componentWillUnmount',

  1612.       'Normal componentWillUnmount',

  1613.     ]);

  1614.   });

  1615. 

  1616.   it('can update multiple times in error state', () => {

  1617.     const container = document.createElement('div');

  1618.     ReactDOM.render(

  1619.       <ErrorBoundary>

  1620.         <BrokenRender />

  1621.       </ErrorBoundary>,

  1622.       container,

  1623.     );

  1624.     expect(container.textContent).toBe('Caught an error: Hello.');

  1625. 

  1626.     ReactDOM.render(

  1627.       <ErrorBoundary>

  1628.         <BrokenRender />

  1629.       </ErrorBoundary>,

  1630.       container,

  1631.     );

  1632.     expect(container.textContent).toBe('Caught an error: Hello.');

  1633. 

  1634.     ReactDOM.render(<div>Other screen</div>, container);

  1635.     expect(container.textContent).toBe('Other screen');

  1636. 

  1637.     ReactDOM.unmountComponentAtNode(container);

  1638.   });

  1639. 

  1640.   it("doesn't get into inconsistent state during removals", () => {

  1641.     const container = document.createElement('div');

  1642.     ReactDOM.render(

  1643.       <ErrorBoundary>

  1644.         <Normal />

  1645.         <BrokenComponentWillUnmount />

  1646.         <Normal />

  1647.       </ErrorBoundary>,

  1648.       container,

  1649.     );

  1650. 

  1651.     ReactDOM.render(<ErrorBoundary />, container);

  1652.     expect(container.textContent).toBe('Caught an error: Hello.');

  1653. 

  1654.     Scheduler.unstable_clearLog();

  1655.     ReactDOM.unmountComponentAtNode(container);

  1656.     assertLog(['ErrorBoundary componentWillUnmount']);

  1657.   });

  1658. 

  1659.   it("doesn't get into inconsistent state during additions", () => {

  1660.     const container = document.createElement('div');

  1661.     ReactDOM.render(<ErrorBoundary />, container);

  1662.     ReactDOM.render(

  1663.       <ErrorBoundary>

  1664.         <Normal />

  1665.         <BrokenRender />

  1666.         <Normal />

  1667.       </ErrorBoundary>,

  1668.       container,

  1669.     );

  1670.     expect(container.textContent).toBe('Caught an error: Hello.');

  1671. 

  1672.     Scheduler.unstable_clearLog();

  1673.     ReactDOM.unmountComponentAtNode(container);

  1674.     assertLog(['ErrorBoundary componentWillUnmount']);

  1675.   });

  1676. 

  1677.   it("doesn't get into inconsistent state during reorders", () => {

  1678.     function getAMixOfNormalAndBrokenRenderElements() {

  1679.       const elements = [];

  1680.       for (let i = 0; i < 100; i++) {

  1681.         elements.push(<Normal key={i} />);

  1682.       }

  1683.       elements.push(<MaybeBrokenRender key={100} />);

  1684. 

  1685.       let currentIndex = elements.length;

  1686.       while (0 !== currentIndex) {

  1687.         const randomIndex = Math.floor(Math.random() * currentIndex);

  1688.         currentIndex -= 1;

  1689.         const temporaryValue = elements[currentIndex];

  1690.         elements[currentIndex] = elements[randomIndex];

  1691.         elements[randomIndex] = temporaryValue;

  1692.       }

  1693.       return elements;

  1694.     }

  1695. 

  1696.     class MaybeBrokenRender extends React.Component {

  1697.       render() {

  1698.         if (fail) {

  1699.           throw new Error('Hello');

  1700.         }

  1701.         return <div>{this.props.children}</div>;

  1702.       }

  1703.     }

  1704. 

  1705.     let fail = false;

  1706.     const container = document.createElement('div');

  1707.     ReactDOM.render(

  1708.       <ErrorBoundary>{getAMixOfNormalAndBrokenRenderElements()}</ErrorBoundary>,

  1709.       container,

  1710.     );

  1711.     expect(container.textContent).not.toContain('Caught an error');

  1712. 

  1713.     fail = true;

  1714.     ReactDOM.render(

  1715.       <ErrorBoundary>{getAMixOfNormalAndBrokenRenderElements()}</ErrorBoundary>,

  1716.       container,

  1717.     );

  1718.     expect(container.textContent).toBe('Caught an error: Hello.');

  1719. 

  1720.     Scheduler.unstable_clearLog();

  1721.     ReactDOM.unmountComponentAtNode(container);

  1722.     assertLog(['ErrorBoundary componentWillUnmount']);

  1723.   });

  1724. 

  1725.   it('catches errors originating downstream', () => {

  1726.     let fail = false;

  1727.     class Stateful extends React.Component {

  1728.       state = {shouldThrow: false};

  1729. 

  1730.       render() {

  1731.         if (fail) {

  1732.           Scheduler.log('Stateful render [!]');

  1733.           throw new Error('Hello');

  1734.         }

  1735.         return <div>{this.props.children}</div>;

  1736.       }

  1737.     }

  1738. 

  1739.     let statefulInst;

  1740.     const container = document.createElement('div');

  1741.     ReactDOM.render(

  1742.       <ErrorBoundary>

  1743.         <Stateful ref={inst => (statefulInst = inst)} />

  1744.       </ErrorBoundary>,

  1745.       container,

  1746.     );

  1747. 

  1748.     Scheduler.unstable_clearLog();

  1749.     expect(() => {

  1750.       fail = true;

  1751.       statefulInst.forceUpdate();

  1752.     }).not.toThrow();

  1753. 

  1754.     assertLog([

  1755.       'Stateful render [!]',

  1756.       'ErrorBoundary static getDerivedStateFromError',

  1757.       'ErrorBoundary componentWillUpdate',

  1758.       'ErrorBoundary render error',

  1759.       'ErrorBoundary componentDidUpdate',

  1760.     ]);

  1761. 

  1762.     ReactDOM.unmountComponentAtNode(container);

  1763.     assertLog(['ErrorBoundary componentWillUnmount']);

  1764.   });

  1765. 

  1766.   it('catches errors in componentDidMount', () => {

  1767.     const container = document.createElement('div');

  1768.     ReactDOM.render(

  1769.       <ErrorBoundary>

  1770.         <BrokenComponentWillUnmount>

  1771.           <Normal />

  1772.         </BrokenComponentWillUnmount>

  1773.         <BrokenComponentDidMount />

  1774.         <Normal logName="LastChild" />

  1775.       </ErrorBoundary>,

  1776.       container,

  1777.     );

  1778.     assertLog([

  1779.       'ErrorBoundary constructor',

  1780.       'ErrorBoundary componentWillMount',

  1781.       'ErrorBoundary render success',

  1782.       'BrokenComponentWillUnmount constructor',

  1783.       'BrokenComponentWillUnmount componentWillMount',

  1784.       'BrokenComponentWillUnmount render',

  1785.       'Normal constructor',

  1786.       'Normal componentWillMount',

  1787.       'Normal render',

  1788.       'BrokenComponentDidMount constructor',

  1789.       'BrokenComponentDidMount componentWillMount',

  1790.       'BrokenComponentDidMount render',

  1791.       'LastChild constructor',

  1792.       'LastChild componentWillMount',

  1793.       'LastChild render',

  1794.       // Start flushing didMount queue

  1795.       'Normal componentDidMount',

  1796.       'BrokenComponentWillUnmount componentDidMount',

  1797.       'BrokenComponentDidMount componentDidMount [!]',

  1798.       // Continue despite the error

  1799.       'LastChild componentDidMount',

  1800.       // Now we are ready to handle the error

  1801.       'ErrorBoundary componentDidMount',

  1802.       'ErrorBoundary static getDerivedStateFromError',

  1803.       'ErrorBoundary componentWillUpdate',

  1804.       'ErrorBoundary render error',

  1805.       // Safely unmount every child

  1806.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  1807.       // Continue unmounting safely despite any errors

  1808.       'Normal componentWillUnmount',

  1809.       'BrokenComponentDidMount componentWillUnmount',

  1810.       'LastChild componentWillUnmount',

  1811.       // The willUnmount error should be captured and logged, too.

  1812.       'ErrorBoundary componentDidUpdate',

  1813.       'ErrorBoundary static getDerivedStateFromError',

  1814.       'ErrorBoundary componentWillUpdate',

  1815.       'ErrorBoundary render error',

  1816.       // The update has finished

  1817.       'ErrorBoundary componentDidUpdate',

  1818.     ]);

  1819. 

  1820.     ReactDOM.unmountComponentAtNode(container);

  1821.     assertLog(['ErrorBoundary componentWillUnmount']);

  1822.   });

  1823. 

  1824.   it('catches errors in componentDidUpdate', () => {

  1825.     const container = document.createElement('div');

  1826.     ReactDOM.render(

  1827.       <ErrorBoundary>

  1828.         <BrokenComponentDidUpdate />

  1829.       </ErrorBoundary>,

  1830.       container,

  1831.     );

  1832. 

  1833.     Scheduler.unstable_clearLog();

  1834.     ReactDOM.render(

  1835.       <ErrorBoundary>

  1836.         <BrokenComponentDidUpdate />

  1837.       </ErrorBoundary>,

  1838.       container,

  1839.     );

  1840.     assertLog([

  1841.       'ErrorBoundary componentWillReceiveProps',

  1842.       'ErrorBoundary componentWillUpdate',

  1843.       'ErrorBoundary render success',

  1844.       'BrokenComponentDidUpdate componentWillReceiveProps',

  1845.       'BrokenComponentDidUpdate componentWillUpdate',

  1846.       'BrokenComponentDidUpdate render',

  1847.       // All lifecycles run

  1848.       'BrokenComponentDidUpdate componentDidUpdate [!]',

  1849.       'ErrorBoundary componentDidUpdate',

  1850.       // Then, error is handled

  1851.       'ErrorBoundary static getDerivedStateFromError',

  1852.       'ErrorBoundary componentWillUpdate',

  1853.       'ErrorBoundary render error',

  1854.       'BrokenComponentDidUpdate componentWillUnmount',

  1855.       'ErrorBoundary componentDidUpdate',

  1856.     ]);

  1857. 

  1858.     ReactDOM.unmountComponentAtNode(container);

  1859.     assertLog(['ErrorBoundary componentWillUnmount']);

  1860.   });

  1861. 

  1862.   it('catches errors in useEffect', async () => {

  1863.     const container = document.createElement('div');

  1864.     await act(() => {

  1865.       ReactDOM.render(

  1866.         <ErrorBoundary>

  1867.           <BrokenUseEffect>Initial value</BrokenUseEffect>

  1868.         </ErrorBoundary>,

  1869.         container,

  1870.       );

  1871.       assertLog([

  1872.         'ErrorBoundary constructor',

  1873.         'ErrorBoundary componentWillMount',

  1874.         'ErrorBoundary render success',

  1875.         'BrokenUseEffect render',

  1876.         'ErrorBoundary componentDidMount',

  1877.       ]);

  1878. 

  1879.       expect(container.firstChild.textContent).toBe('Initial value');

  1880.       Scheduler.unstable_clearLog();

  1881.     });

  1882. 

  1883.     // verify flushed passive effects and handle the error

  1884.     assertLog([

  1885.       'BrokenUseEffect useEffect [!]',

  1886.       // Handle the error

  1887.       'ErrorBoundary static getDerivedStateFromError',

  1888.       'ErrorBoundary componentWillUpdate',

  1889.       'ErrorBoundary render error',

  1890.       'ErrorBoundary componentDidUpdate',

  1891.     ]);

  1892. 

  1893.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  1894.   });

  1895. 

  1896.   it('catches errors in useLayoutEffect', () => {

  1897.     const container = document.createElement('div');

  1898.     ReactDOM.render(

  1899.       <ErrorBoundary>

  1900.         <BrokenUseLayoutEffect>Initial value</BrokenUseLayoutEffect>

  1901.       </ErrorBoundary>,

  1902.       container,

  1903.     );

  1904.     assertLog([

  1905.       'ErrorBoundary constructor',

  1906.       'ErrorBoundary componentWillMount',

  1907.       'ErrorBoundary render success',

  1908.       'BrokenUseLayoutEffect render',

  1909.       'BrokenUseLayoutEffect useLayoutEffect [!]',

  1910.       // Fiber proceeds with the hooks

  1911.       'ErrorBoundary componentDidMount',

  1912.       // The error propagates to the higher boundary

  1913.       'ErrorBoundary static getDerivedStateFromError',

  1914.       // Fiber retries from the root

  1915.       'ErrorBoundary componentWillUpdate',

  1916.       'ErrorBoundary render error',

  1917.       'ErrorBoundary componentDidUpdate',

  1918.     ]);

  1919. 

  1920.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  1921.   });

  1922. 

  1923.   it('propagates errors inside boundary during componentDidMount', () => {

  1924.     const container = document.createElement('div');

  1925.     ReactDOM.render(

  1926.       <ErrorBoundary>

  1927.         <BrokenComponentDidMountErrorBoundary

  1928.           renderError={error => (

  1929.             <div>We should never catch our own error: {error.message}.</div>

  1930.           )}

  1931.         />

  1932.       </ErrorBoundary>,

  1933.       container,

  1934.     );

  1935.     expect(container.firstChild.textContent).toBe('Caught an error: Hello.');

  1936.     assertLog([

  1937.       'ErrorBoundary constructor',

  1938.       'ErrorBoundary componentWillMount',

  1939.       'ErrorBoundary render success',

  1940.       'BrokenComponentDidMountErrorBoundary constructor',

  1941.       'BrokenComponentDidMountErrorBoundary componentWillMount',

  1942.       'BrokenComponentDidMountErrorBoundary render success',

  1943.       'BrokenComponentDidMountErrorBoundary componentDidMount [!]',

  1944.       // Fiber proceeds with the hooks

  1945.       'ErrorBoundary componentDidMount',

  1946.       // The error propagates to the higher boundary

  1947.       'ErrorBoundary static getDerivedStateFromError',

  1948.       // Fiber retries from the root

  1949.       'ErrorBoundary componentWillUpdate',

  1950.       'ErrorBoundary render error',

  1951.       'BrokenComponentDidMountErrorBoundary componentWillUnmount',

  1952.       'ErrorBoundary componentDidUpdate',

  1953.     ]);

  1954. 

  1955.     ReactDOM.unmountComponentAtNode(container);

  1956.     assertLog(['ErrorBoundary componentWillUnmount']);

  1957.   });

  1958. 

  1959.   it('calls static getDerivedStateFromError for each error that is captured', () => {

  1960.     function renderUnmountError(error) {

  1961.       return <div>Caught an unmounting error: {error.message}.</div>;

  1962.     }

  1963.     function renderUpdateError(error) {

  1964.       return <div>Caught an updating error: {error.message}.</div>;

  1965.     }

  1966. 

  1967.     const container = document.createElement('div');

  1968.     ReactDOM.render(

  1969.       <ErrorBoundary logName="OuterErrorBoundary">

  1970.         <ErrorBoundary

  1971.           logName="InnerUnmountBoundary"

  1972.           renderError={renderUnmountError}>

  1973.           <BrokenComponentWillUnmount errorText="E1" />

  1974.           <BrokenComponentWillUnmount errorText="E2" />

  1975.         </ErrorBoundary>

  1976.         <ErrorBoundary

  1977.           logName="InnerUpdateBoundary"

  1978.           renderError={renderUpdateError}>

  1979.           <BrokenComponentDidUpdate errorText="E3" />

  1980.           <BrokenComponentDidUpdate errorText="E4" />

  1981.         </ErrorBoundary>

  1982.       </ErrorBoundary>,

  1983.       container,

  1984.     );

  1985. 

  1986.     Scheduler.unstable_clearLog();

  1987.     ReactDOM.render(

  1988.       <ErrorBoundary logName="OuterErrorBoundary">

  1989.         <ErrorBoundary

  1990.           logName="InnerUnmountBoundary"

  1991.           renderError={renderUnmountError}

  1992.         />

  1993.         <ErrorBoundary

  1994.           logName="InnerUpdateBoundary"

  1995.           renderError={renderUpdateError}>

  1996.           <BrokenComponentDidUpdate errorText="E3" />

  1997.           <BrokenComponentDidUpdate errorText="E4" />

  1998.         </ErrorBoundary>

  1999.       </ErrorBoundary>,

  2000.       container,

  2001.     );

  2002. 

  2003.     expect(container.firstChild.textContent).toBe(

  2004.       'Caught an unmounting error: E2.' + 'Caught an updating error: E4.',

  2005.     );

  2006.     assertLog([

  2007.       // Begin update phase

  2008.       'OuterErrorBoundary componentWillReceiveProps',

  2009.       'OuterErrorBoundary componentWillUpdate',

  2010.       'OuterErrorBoundary render success',

  2011.       'InnerUnmountBoundary componentWillReceiveProps',

  2012.       'InnerUnmountBoundary componentWillUpdate',

  2013.       'InnerUnmountBoundary render success',

  2014.       'InnerUpdateBoundary componentWillReceiveProps',

  2015.       'InnerUpdateBoundary componentWillUpdate',

  2016.       'InnerUpdateBoundary render success',

  2017.       // First come the updates

  2018.       'BrokenComponentDidUpdate componentWillReceiveProps',

  2019.       'BrokenComponentDidUpdate componentWillUpdate',

  2020.       'BrokenComponentDidUpdate render',

  2021.       'BrokenComponentDidUpdate componentWillReceiveProps',

  2022.       'BrokenComponentDidUpdate componentWillUpdate',

  2023.       'BrokenComponentDidUpdate render',

  2024.       // We're in commit phase now, deleting

  2025.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  2026.       'BrokenComponentWillUnmount componentWillUnmount [!]',

  2027.       // Continue despite errors, handle them after commit is done

  2028.       'InnerUnmountBoundary componentDidUpdate',

  2029.       // We're still in commit phase, now calling update lifecycles

  2030.       'BrokenComponentDidUpdate componentDidUpdate [!]',

  2031.       // Again, continue despite errors, we'll handle them later

  2032.       'BrokenComponentDidUpdate componentDidUpdate [!]',

  2033.       'InnerUpdateBoundary componentDidUpdate',

  2034.       'OuterErrorBoundary componentDidUpdate',

  2035.       // After the commit phase, attempt to recover from any errors that

  2036.       // were captured

  2037.       'ErrorBoundary static getDerivedStateFromError',

  2038.       'ErrorBoundary static getDerivedStateFromError',

  2039.       'InnerUnmountBoundary componentWillUpdate',

  2040.       'InnerUnmountBoundary render error',

  2041.       'ErrorBoundary static getDerivedStateFromError',

  2042.       'ErrorBoundary static getDerivedStateFromError',

  2043.       'InnerUpdateBoundary componentWillUpdate',

  2044.       'InnerUpdateBoundary render error',

  2045.       'BrokenComponentDidUpdate componentWillUnmount',

  2046.       'BrokenComponentDidUpdate componentWillUnmount',

  2047.       'InnerUnmountBoundary componentDidUpdate',

  2048.       'InnerUpdateBoundary componentDidUpdate',

  2049.     ]);

  2050. 

  2051.     ReactDOM.unmountComponentAtNode(container);

  2052.     assertLog([

  2053.       'OuterErrorBoundary componentWillUnmount',

  2054.       'InnerUnmountBoundary componentWillUnmount',

  2055.       'InnerUpdateBoundary componentWillUnmount',

  2056.     ]);

  2057.   });

  2058. 

  2059.   it('discards a bad root if the root component fails', () => {

  2060.     const X = null;

  2061.     const Y = undefined;

  2062.     let err1;

  2063.     let err2;

  2064. 

  2065.     try {

  2066.       const container = document.createElement('div');

  2067.       expect(() => ReactDOM.render(<X />, container)).toErrorDev(

  2068.         'React.createElement: type is invalid -- expected a string ' +

  2069.           '(for built-in components) or a class/function ' +

  2070.           '(for composite components) but got: null.',

  2071.       );

  2072.     } catch (err) {

  2073.       err1 = err;

  2074.     }

  2075.     try {

  2076.       const container = document.createElement('div');

  2077.       expect(() => ReactDOM.render(<Y />, container)).toErrorDev(

  2078.         'React.createElement: type is invalid -- expected a string ' +

  2079.           '(for built-in components) or a class/function ' +

  2080.           '(for composite components) but got: undefined.',

  2081.       );

  2082.     } catch (err) {

  2083.       err2 = err;

  2084.     }

  2085. 

  2086.     expect(err1.message).toMatch(/got: null/);

  2087.     expect(err2.message).toMatch(/got: undefined/);

  2088.   });

  2089. 

  2090.   it('renders empty output if error boundary does not handle the error', () => {

  2091.     const container = document.createElement('div');

  2092.     expect(() =>

  2093.       ReactDOM.render(

  2094.         <div>

  2095.           Sibling

  2096.           <NoopErrorBoundary>

  2097.             <BrokenRender />

  2098.           </NoopErrorBoundary>

  2099.         </div>,

  2100.         container,

  2101.       ),

  2102.     ).toThrow('Hello');

  2103.     expect(container.innerHTML).toBe('');

  2104.     assertLog([

  2105.       'NoopErrorBoundary constructor',

  2106.       'NoopErrorBoundary componentWillMount',

  2107.       'NoopErrorBoundary render',

  2108.       'BrokenRender constructor',

  2109.       'BrokenRender componentWillMount',

  2110.       'BrokenRender render [!]',

  2111.       // Noop error boundaries retry render (and fail again)

  2112.       'NoopErrorBoundary static getDerivedStateFromError',

  2113.       'NoopErrorBoundary render',

  2114.       'BrokenRender constructor',

  2115.       'BrokenRender componentWillMount',

  2116.       'BrokenRender render [!]',

  2117.     ]);

  2118.   });

  2119. 

  2120.   it('passes first error when two errors happen in commit', () => {

  2121.     const errors = [];

  2122.     let caughtError;

  2123.     class Parent extends React.Component {

  2124.       render() {

  2125.         return <Child />;

  2126.       }

  2127.       componentDidMount() {

  2128.         errors.push('parent sad');

  2129.         throw new Error('parent sad');

  2130.       }

  2131.     }

  2132.     class Child extends React.Component {

  2133.       render() {

  2134.         return <div />;

  2135.       }

  2136.       componentDidMount() {

  2137.         errors.push('child sad');

  2138.         throw new Error('child sad');

  2139.       }

  2140.     }

  2141. 

  2142.     const container = document.createElement('div');

  2143.     try {

  2144.       // Here, we test the behavior where there is no error boundary and we

  2145.       // delegate to the host root.

  2146.       ReactDOM.render(<Parent />, container);

  2147.     } catch (e) {

  2148.       if (e.message !== 'parent sad' && e.message !== 'child sad') {

  2149.         throw e;

  2150.       }

  2151.       caughtError = e;

  2152.     }

  2153. 

  2154.     expect(errors).toEqual(['child sad', 'parent sad']);

  2155.     // Error should be the first thrown

  2156.     expect(caughtError.message).toBe('child sad');

  2157.   });

  2158. 

  2159.   it('propagates uncaught error inside unbatched initial mount', () => {

  2160.     function Foo() {

  2161.       throw new Error('foo error');

  2162.     }

  2163.     const container = document.createElement('div');

  2164.     expect(() => {

  2165.       ReactDOM.unstable_batchedUpdates(() => {

  2166.         ReactDOM.render(<Foo />, container);

  2167.       });

  2168.     }).toThrow('foo error');

  2169.   });

  2170. 

  2171.   it('handles errors that occur in before-mutation commit hook', () => {

  2172.     const errors = [];

  2173.     let caughtError;

  2174.     class Parent extends React.Component {

  2175.       getSnapshotBeforeUpdate() {

  2176.         errors.push('parent sad');

  2177.         throw new Error('parent sad');

  2178.       }

  2179.       componentDidUpdate() {}

  2180.       render() {

  2181.         return <Child {...this.props} />;

  2182.       }

  2183.     }

  2184.     class Child extends React.Component {

  2185.       getSnapshotBeforeUpdate() {

  2186.         errors.push('child sad');

  2187.         throw new Error('child sad');

  2188.       }

  2189.       componentDidUpdate() {}

  2190.       render() {

  2191.         return <div />;

  2192.       }

  2193.     }

  2194. 

  2195.     const container = document.createElement('div');

  2196.     ReactDOM.render(<Parent value={1} />, container);

  2197.     try {

  2198.       ReactDOM.render(<Parent value={2} />, container);

  2199.     } catch (e) {

  2200.       if (e.message !== 'parent sad' && e.message !== 'child sad') {

  2201.         throw e;

  2202.       }

  2203.       caughtError = e;

  2204.     }

  2205. 

  2206.     expect(errors).toEqual(['child sad', 'parent sad']);

  2207.     // Error should be the first thrown

  2208.     expect(caughtError.message).toBe('child sad');

  2209.   });

  2210. 

  2211.   it('should warn if an error boundary with only componentDidCatch does not update state', () => {

  2212.     class InvalidErrorBoundary extends React.Component {

  2213.       componentDidCatch(error, info) {

  2214.         // This component does not define getDerivedStateFromError().

  2215.         // It also doesn't call setState().

  2216.         // So it would swallow errors (which is probably unintentional).

  2217.       }

  2218.       render() {

  2219.         return this.props.children;

  2220.       }

  2221.     }

  2222. 

  2223.     const Throws = () => {

  2224.       throw new Error('expected');

  2225.     };

  2226. 

  2227.     const container = document.createElement('div');

  2228.     expect(() => {

  2229.       ReactDOM.render(

  2230.         <InvalidErrorBoundary>

  2231.           <Throws />

  2232.         </InvalidErrorBoundary>,

  2233.         container,

  2234.       );

  2235.     }).toErrorDev(

  2236.       'InvalidErrorBoundary: Error boundaries should implement getDerivedStateFromError(). ' +

  2237.         'In that method, return a state update to display an error message or fallback UI.',

  2238.     );

  2239.     expect(container.textContent).toBe('');

  2240.   });

  2241. 

  2242.   it('should call both componentDidCatch and getDerivedStateFromError if both exist on a component', () => {

  2243.     let componentDidCatchError, getDerivedStateFromErrorError;

  2244.     class ErrorBoundaryWithBothMethods extends React.Component {

  2245.       state = {error: null};

  2246.       static getDerivedStateFromError(error) {

  2247.         getDerivedStateFromErrorError = error;

  2248.         return {error};

  2249.       }

  2250.       componentDidCatch(error, info) {

  2251.         componentDidCatchError = error;

  2252.       }

  2253.       render() {

  2254.         return this.state.error ? 'ErrorBoundary' : this.props.children;

  2255.       }

  2256.     }

  2257. 

  2258.     const thrownError = new Error('expected');

  2259.     const Throws = () => {

  2260.       throw thrownError;

  2261.     };

  2262. 

  2263.     const container = document.createElement('div');

  2264.     ReactDOM.render(

  2265.       <ErrorBoundaryWithBothMethods>

  2266.         <Throws />

  2267.       </ErrorBoundaryWithBothMethods>,

  2268.       container,

  2269.     );

  2270.     expect(container.textContent).toBe('ErrorBoundary');

  2271.     expect(componentDidCatchError).toBe(thrownError);

  2272.     expect(getDerivedStateFromErrorError).toBe(thrownError);

  2273.   });

  2274. 

  2275.   it('should catch errors from invariants in completion phase', () => {

  2276.     const container = document.createElement('div');

  2277.     ReactDOM.render(

  2278.       <ErrorBoundary>

  2279.         <input>

  2280.           <div />

  2281.         </input>

  2282.       </ErrorBoundary>,

  2283.       container,

  2284.     );

  2285.     expect(container.textContent).toContain(

  2286.       'Caught an error: input is a void element tag',

  2287.     );

  2288.   });

  2289. 

  2290.   it('should catch errors from errors in the throw phase from boundaries', () => {

  2291.     const container = document.createElement('div');

  2292. 

  2293.     const thrownError = new Error('original error');

  2294.     const Throws = () => {

  2295.       throw thrownError;

  2296.     };

  2297. 

  2298.     class EvilErrorBoundary extends React.Component {

  2299.       get componentDidCatch() {

  2300.         throw new Error('gotta catch em all');

  2301.       }

  2302.       render() {

  2303.         return this.props.children;

  2304.       }

  2305.     }

  2306. 

  2307.     ReactDOM.render(

  2308.       <ErrorBoundary>

  2309.         <EvilErrorBoundary>

  2310.           <Throws />

  2311.         </EvilErrorBoundary>

  2312.       </ErrorBoundary>,

  2313.       container,

  2314.     );

  2315. 

  2316.     expect(container.textContent).toContain(

  2317.       'Caught an error: gotta catch em all',

  2318.     );

  2319.   });

  2320. 

  2321.   it('should protect errors from errors in the stack generation', () => {

  2322.     const container = document.createElement('div');

  2323. 

  2324.     const evilError = {

  2325.       message: 'gotta catch em all',

  2326.       get stack() {

  2327.         throw new Error('gotta catch em all');

  2328.       },

  2329.     };

  2330.     const Throws = () => {

  2331.       throw evilError;

  2332.     };

  2333.     Object.defineProperty(Throws, 'displayName', {

  2334.       get: function () {

  2335.         throw new Error('gotta catch em all');

  2336.       },

  2337.     });

  2338. 

  2339.     function Wrapper() {

  2340.       return <Throws />;

  2341.     }

  2342. 

  2343.     ReactDOM.render(

  2344.       <ErrorBoundary>

  2345.         <Wrapper />

  2346.       </ErrorBoundary>,

  2347.       container,

  2348.     );

  2349. 

  2350.     expect(container.textContent).toContain(

  2351.       'Caught an error: gotta catch em all.',

  2352.     );

  2353.   });

  2354. 

  2355.   it('catches errors thrown in componentWillUnmount', () => {

  2356.     class LocalErrorBoundary extends React.Component {

  2357.       state = {error: null};

  2358.       static getDerivedStateFromError(error) {

  2359.         Scheduler.log(`ErrorBoundary static getDerivedStateFromError`);

  2360.         return {error};

  2361.       }

  2362.       render() {

  2363.         const {children, id, fallbackID} = this.props;

  2364.         const {error} = this.state;

  2365.         if (error) {

  2366.           Scheduler.log(`${id} render error`);

  2367.           return <Component id={fallbackID} />;

  2368.         }

  2369.         Scheduler.log(`${id} render success`);

  2370.         return children || null;

  2371.       }

  2372.     }

  2373. 

  2374.     class Component extends React.Component {

  2375.       render() {

  2376.         const {id} = this.props;

  2377.         Scheduler.log('Component render ' + id);

  2378.         return id;

  2379.       }

  2380.     }

  2381. 

  2382.     class LocalBrokenComponentWillUnmount extends React.Component {

  2383.       componentWillUnmount() {

  2384.         Scheduler.log('BrokenComponentWillUnmount componentWillUnmount');

  2385.         throw Error('Expected');

  2386.       }

  2387. 

  2388.       render() {

  2389.         Scheduler.log('BrokenComponentWillUnmount render');

  2390.         return 'broken';

  2391.       }

  2392.     }

  2393. 

  2394.     const container = document.createElement('div');

  2395. 

  2396.     ReactDOM.render(

  2397.       <LocalErrorBoundary id="OuterBoundary" fallbackID="OuterFallback">

  2398.         <Component id="sibling" />

  2399.         <LocalErrorBoundary id="InnerBoundary" fallbackID="InnerFallback">

  2400.           <LocalBrokenComponentWillUnmount />

  2401.         </LocalErrorBoundary>

  2402.       </LocalErrorBoundary>,

  2403.       container,

  2404.     );

  2405. 

  2406.     expect(container.firstChild.textContent).toBe('sibling');

  2407.     expect(container.lastChild.textContent).toBe('broken');

  2408.     assertLog([

  2409.       'OuterBoundary render success',

  2410.       'Component render sibling',

  2411.       'InnerBoundary render success',

  2412.       'BrokenComponentWillUnmount render',

  2413.     ]);

  2414. 

  2415.     ReactDOM.render(

  2416.       <LocalErrorBoundary id="OuterBoundary" fallbackID="OuterFallback">

  2417.         <Component id="sibling" />

  2418.       </LocalErrorBoundary>,

  2419.       container,

  2420.     );

  2421. 

  2422.     // React should skip over the unmounting boundary and find the nearest still-mounted boundary.

  2423.     expect(container.firstChild.textContent).toBe('OuterFallback');

  2424.     expect(container.lastChild.textContent).toBe('OuterFallback');

  2425.     assertLog([

  2426.       'OuterBoundary render success',

  2427.       'Component render sibling',

  2428.       'BrokenComponentWillUnmount componentWillUnmount',

  2429.       'ErrorBoundary static getDerivedStateFromError',

  2430.       'OuterBoundary render error',

  2431.       'Component render OuterFallback',

  2432.     ]);

  2433.   });

  2434. 

  2435.   it('catches errors thrown while detaching refs', () => {

  2436.     class LocalErrorBoundary extends React.Component {

  2437.       state = {error: null};

  2438.       static getDerivedStateFromError(error) {

  2439.         Scheduler.log(`ErrorBoundary static getDerivedStateFromError`);

  2440.         return {error};

  2441.       }

  2442.       render() {

  2443.         const {children, id, fallbackID} = this.props;

  2444.         const {error} = this.state;

  2445.         if (error) {

  2446.           Scheduler.log(`${id} render error`);

  2447.           return <Component id={fallbackID} />;

  2448.         }

  2449.         Scheduler.log(`${id} render success`);

  2450.         return children || null;

  2451.       }

  2452.     }

  2453. 

  2454.     class Component extends React.Component {

  2455.       render() {

  2456.         const {id} = this.props;

  2457.         Scheduler.log('Component render ' + id);

  2458.         return id;

  2459.       }

  2460.     }

  2461. 

  2462.     class LocalBrokenCallbackRef extends React.Component {

  2463.       _ref = ref => {

  2464.         Scheduler.log('LocalBrokenCallbackRef ref ' + !!ref);

  2465.         if (ref === null) {

  2466.           throw Error('Expected');

  2467.         }

  2468.       };

  2469. 

  2470.       render() {

  2471.         Scheduler.log('LocalBrokenCallbackRef render');

  2472.         return <div ref={this._ref}>ref</div>;

  2473.       }

  2474.     }

  2475. 

  2476.     const container = document.createElement('div');

  2477. 

  2478.     ReactDOM.render(

  2479.       <LocalErrorBoundary id="OuterBoundary" fallbackID="OuterFallback">

  2480.         <Component id="sibling" />

  2481.         <LocalErrorBoundary id="InnerBoundary" fallbackID="InnerFallback">

  2482.           <LocalBrokenCallbackRef />

  2483.         </LocalErrorBoundary>

  2484.       </LocalErrorBoundary>,

  2485.       container,

  2486.     );

  2487. 

  2488.     expect(container.firstChild.textContent).toBe('sibling');

  2489.     expect(container.lastChild.textContent).toBe('ref');

  2490.     assertLog([

  2491.       'OuterBoundary render success',

  2492.       'Component render sibling',

  2493.       'InnerBoundary render success',

  2494.       'LocalBrokenCallbackRef render',

  2495.       'LocalBrokenCallbackRef ref true',

  2496.     ]);

  2497. 

  2498.     ReactDOM.render(

  2499.       <LocalErrorBoundary id="OuterBoundary" fallbackID="OuterFallback">

  2500.         <Component id="sibling" />

  2501.       </LocalErrorBoundary>,

  2502.       container,

  2503.     );

  2504. 

  2505.     // React should skip over the unmounting boundary and find the nearest still-mounted boundary.

  2506.     expect(container.firstChild.textContent).toBe('OuterFallback');

  2507.     expect(container.lastChild.textContent).toBe('OuterFallback');

  2508.     assertLog([

  2509.       'OuterBoundary render success',

  2510.       'Component render sibling',

  2511.       'LocalBrokenCallbackRef ref false',

  2512.       'ErrorBoundary static getDerivedStateFromError',

  2513.       'OuterBoundary render error',

  2514.       'Component render OuterFallback',

  2515.     ]);

  2516.   });

  2517. });
About Sign Up Leave Feedback Contact