Use a closure to bind argument to callback in ReactErrorUtils (#8363)

* Use a closure to bind gaurded callback

This way the fake event isn't being implicitly passed into the event handler

* Add tests for ReactErrorUtils

Add fiber test report

Linting fixes

src/renderers/shared/utils/ReactErrorUtils.js

@@ -75,7 +75,9 @@ if (__DEV__) {
       func: (a: A) => void,
       a: A,
     ): void {
-      var boundFunc = func.bind(null, a);
+      var boundFunc = function() {
+        func(a);
+      };
       var evtType = `react-${name}`;
       fakeNode.addEventListener(evtType, boundFunc, false);
       var evt = document.createEvent('Event');

src/renderers/shared/utils/__tests__/ReactErrorUtils-test.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @emails react-core
+ */
+
+'use strict';
+
+var ReactErrorUtils;
+
+describe('ReactErrorUtils', () => {
+  beforeEach(() => {
+    ReactErrorUtils = require('ReactErrorUtils');
+  });
+
+  describe('invokeGuardedCallbackWithCatch', () => {
+    it('should call the callback with only the passed argument', () => {
+      var callback = jest.fn();
+      ReactErrorUtils.invokeGuardedCallbackWithCatch('foo', callback, 'arg');
+      expect(callback).toBeCalledWith('arg');
+    });
+
+    it('should catch errors', () => {
+      var callback = function() {
+        throw new Error('foo');
+      };
+      expect(() =>
+        ReactErrorUtils.invokeGuardedCallbackWithCatch('foo', callback),
+      ).not.toThrow();
+    });
+  });
+
+  describe('rethrowCaughtError', () => {
+    it('should rethrow caught errors', () => {
+      var err = new Error('foo');
+      var callback = function() {
+        throw err;
+      };
+      ReactErrorUtils.invokeGuardedCallbackWithCatch('foo', callback);
+      expect(() => ReactErrorUtils.rethrowCaughtError()).toThrow(err);
+    });
+  });
+
+  describe('invokeGuardedCallback', () => {
+    it('should call the callback with only the passed argument', () => {
+      var callback = jest.fn();
+      ReactErrorUtils.invokeGuardedCallback('foo', callback, 'arg');
+      expect(callback).toBeCalledWith('arg');
+    });
+
+    it('should use invokeGuardedCallbackWithCatch in production', () => {
+      expect(ReactErrorUtils.invokeGuardedCallback).not.toEqual(
+        ReactErrorUtils.invokeGuardedCallbackWithCatch,
+      );
+      __DEV__ = false;
+      var oldProcess = process;
+      global.process = {env: {NODE_ENV: 'production'}};
+      jest.resetModuleRegistry();
+      ReactErrorUtils = require('ReactErrorUtils');
+      expect(ReactErrorUtils.invokeGuardedCallback).toEqual(
+        ReactErrorUtils.invokeGuardedCallbackWithCatch,
+      );
+      __DEV__ = true;
+      global.process = oldProcess;
+    });
+  });
+});