text: 'use strict';Object.defineProperty(exports, "__esModule", { value: true });
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  // Keeping the core of "runTest" as a separate function (as "runTestInternal")
  // is key to be able to detect memory leaks. Since all variables are local to
  // the function, when "runTestInternal" finishes its execution, they can all be
  // freed, UNLESS something else is leaking them (and that's why we can detect
  // the leak!).
  //
  // If we had all the code in a single function, we should manually nullify all
  // references to verify if there is a leak, which is not maintainable and error
  // prone. That's why "runTestInternal" CANNOT be inlined inside "runTest".
  let runTestInternal = (() => {var _ref = _asyncToGenerator(function* (
    path,
    globalConfig,
    config,
    resolver)
    {
      const testSource = (_fs || _load_fs()).default.readFileSync(path, 'utf8');
      const parsedDocblock = (_jestDocblock || _load_jestDocblock()).parse((_jestDocblock || _load_jestDocblock()).extract(testSource));
      const customEnvironment = parsedDocblock['jest-environment'];
  
      let testEnvironment = config.testEnvironment;
  
      if (customEnvironment) {
        testEnvironment = (0, (_jestConfig || _load_jestConfig()).getTestEnvironment)(
        Object.assign({}, config, {
          testEnvironment: customEnvironment }));
  
  
      }
  
      /* $FlowFixMe */
      const TestEnvironment = require(testEnvironment);
      /* $FlowFixMe */
      const testFramework = require(config.testRunner);
      /* $FlowFixMe */
      const Runtime = require(config.moduleLoader || 'jest-runtime');
  
  
  
      const consoleOut = globalConfig.useStderr ? process.stderr : process.stdout;
      const consoleFormatter = function (type, message) {return (
          (0, (_jestUtil || _load_jestUtil()).getConsoleOutput)(
          config.cwd,
          !!globalConfig.verbose,
          // 4 = the console call is buried 4 stack frames deep
          (_jestUtil || _load_jestUtil()).BufferedConsole.write([], type, message, 4)));};
  
  
      let testConsole;
  
      if (globalConfig.silent) {
        testConsole = new (_jestUtil || _load_jestUtil()).NullConsole(consoleOut, process.stderr, consoleFormatter);
      } else if (globalConfig.verbose) {
        testConsole = new (_jestUtil || _load_jestUtil()).Console(consoleOut, process.stderr, consoleFormatter);
      } else {
        testConsole = new (_jestUtil || _load_jestUtil()).BufferedConsole();
      }
  
      const environment = new TestEnvironment(config, { console: testConsole });
      const leakDetector = config.detectLeaks ?
      new (_jestLeakDetector || _load_jestLeakDetector()).default(environment) :
      null;
  
      const cacheFS = { [path]: testSource };
      (0, (_jestUtil || _load_jestUtil()).setGlobal)(environment.global, 'console', testConsole);
  
      const runtime = new Runtime(config, environment, resolver, cacheFS, {
        collectCoverage: globalConfig.collectCoverage,
        collectCoverageFrom: globalConfig.collectCoverageFrom,
        collectCoverageOnlyFrom: globalConfig.collectCoverageOnlyFrom,
        mapCoverage: globalConfig.mapCoverage });
  
  
      const start = Date.now();
      yield environment.setup();
      try {
        const result = yield testFramework(
        globalConfig,
        config,
        environment,
        runtime,
        path);
  
        const testCount =
        result.numPassingTests + result.numFailingTests + result.numPendingTests;
  
        result.perfStats = { end: Date.now(), start };
        result.testFilePath = path;
        result.coverage = runtime.getAllCoverageInfoCopy();
        result.sourceMaps = runtime.getSourceMapInfo();
        result.console = testConsole.getBuffer();
        result.skipped = testCount === result.numPendingTests;
        result.displayName = config.displayName;
  
        if (globalConfig.logHeapUsage) {
          if (global.gc) {
            global.gc();
          }
          result.memoryUsage = process.memoryUsage().heapUsed;
        }
  
        // Delay the resolution to allow log messages to be output.
        return new Promise(function (resolve) {
          setImmediate(function () {return resolve({ leakDetector, result });});
        });
      } finally {
        yield environment.teardown();
      }
    });return function runTestInternal(_x, _x2, _x3, _x4) {return _ref.apply(this, arguments);};})();var _fs;function _load_fs() {return _fs = _interopRequireDefault(require('fs'));}var _jestUtil;function _load_jestUtil() {return _jestUtil = require('jest-util');}var _jestJasmine;function _load_jestJasmine() {return _jestJasmine = _interopRequireDefault(require('jest-jasmine2'));}var _jestLeakDetector;function _load_jestLeakDetector() {return _jestLeakDetector = _interopRequireDefault(require('jest-leak-detector'));}var _jestConfig;function _load_jestConfig() {return _jestConfig = require('jest-config');}var _jestDocblock;function _load_jestDocblock() {return _jestDocblock = _interopRequireWildcard(require('jest-docblock'));}function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj.default = obj;return newObj;}}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}function _asyncToGenerator(fn) {return function () {var gen = fn.apply(this, arguments);return new Promise(function (resolve, reject) {function step(key, arg) {try {var info = gen[key](arg);var value = info.value;} catch (error) {reject(error);return;}if (info.done) {resolve(value);} else {return Promise.resolve(value).then(function (value) {step("next", value);}, function (err) {step("throw", err);});}}return step("next");});};} /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               * This source code is licensed under the MIT license found in the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               * LICENSE file in the root directory of this source tree.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               * 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               */ // The default jest-runner is required because it is the default test runner
  // and required implicitly through the `testRunner` ProjectConfig option.
  (_jestJasmine || _load_jestJasmine()).default;exports.default = (() => {var _ref2 = _asyncToGenerator(function* (path, globalConfig, config, resolver) {var _ref3 = yield runTestInternal(path,
      globalConfig,
      config,
      resolver);const leakDetector = _ref3.leakDetector,result = _ref3.result;
  
  
      // Resolve leak detector, outside the "runTestInternal" closure.
      result.leaks = leakDetector ? leakDetector.isLeaking() : false;
  
      return result;
    });function runTest(_x5, _x6, _x7, _x8) {return _ref2.apply(this, arguments);}return runTest;})();