export async function worker({
  config,
  globalConfig,
  path,
  serializableModuleMap,
  context,
}: WorkerData): Promise<TestResult> {
  try {
    const moduleMap = serializableModuleMap
      ? HasteMap.ModuleMap.fromJSON(serializableModuleMap)
      : null;
    return await runTest(
      path,
      globalConfig,
      config,
      getResolver(config, moduleMap),
      context && {
        ...context,
        changedFiles: context.changedFiles && new Set(context.changedFiles),
      },
    );
  } catch (error) {
    throw formatError(error);
  }
}

 it('returns false if `hasCoreModules` is false.', () => {
   const moduleMap = ModuleMap.create('/');
   const resolver = new Resolver(moduleMap, {
     hasCoreModules: false,
   } as ResolverConfig);
   const isCore = resolver.isCoreModule('assert');
   expect(isCore).toEqual(false);
 });

export function setup(setupData: {
  serializableResolvers: Array<SerializableResolver>;
}) {
  // Module maps that will be needed for the test runs are passed.
  for (const {
    config,
    serializableModuleMap,
  } of setupData.serializableResolvers) {
    const moduleMap = HasteMap.ModuleMap.fromJSON(serializableModuleMap);
    resolvers.set(config.name, Runtime.createResolver(config, moduleMap));
  }
}

  beforeEach(() => {
    jest.resetModules();

    moduleMap = ModuleMap.create('/');

    // Mocking realpath to function the old way, where it just looks at
    // pathstrings instead of actually trying to access the physical directory.
    // This test suite won't work otherwise, since we cannot make assumptions
    // about the test environment when it comes to absolute paths.
    jest.doMock('realpath-native', () => ({
      sync: (dirInput: string) => dirInput,
    }));
  });

 getPackage(name: string): Config.Path | null {
   return this._moduleMap.getPackage(
     name,
     this._options.defaultPlatform,
     this._supportsNativePlatform,
   );
 }

 getMockModule(from: Config.Path, name: string): Config.Path | null {
   const mock = this._moduleMap.getMockModule(name);
   if (mock) {
     return mock;
   } else {
     const moduleName = this.resolveStubModuleName(from, name);
     if (moduleName) {
       return this.getModule(moduleName) || moduleName;
     }
   }
   return null;
 }