test('Test load of kit from test file', async () => {
   const kits = await readKitsFile(getTestResourceFilePath('test_kit.json'));
   const names = kits.map(k => k.name);
   expect(names).to.deep.eq([
     'CompilerKit 1',
     'CompilerKit 2',
     'CompilerKit 3 with PreferedGenerator',
     'ToolchainKit 1',
     'VSCode Kit 1',
     'VSCode Kit 2',
   ]);
 });

 test('Input file set maps files correctly', async () => {
   const foo_subdir = path.join(here, 'foo');
   const dummy_file = util.platformNormalizePath(path.join(foo_subdir, 'dummy_file'));
   const fileset = await InputFileSet.create({
     buildFiles: [{
       isCMake: false,
       isTemporary: false,
       sources: [
         'dummy_file',
         foo_subdir,
       ],
     }],
     cmakeRootDirectory: '', // unused
     sourceDirectory: foo_subdir,
   });
   expect(fileset.inputFiles).to.have.lengthOf(2, 'Wrong file count');
   // The relative path 'dummy_file' should have mapped to the full path to the correct file
   expect(fileset.inputFiles[0].filePath).to.eq(dummy_file, 'Filepath mapped incorrectly');
   // The absolute path `foo_subdir` should be kept as-is
   expect(fileset.inputFiles[1].filePath).to.eq(foo_subdir, 'Filepath mapped incorrectly');
   // Since the file doesn't exist, the fileset should tell us it is dirty
   expect(await fileset.checkOutOfDate());
 });

  test('Replace default variant', async () => {
    const variantFile = path.join(testEnv.projectFolder.location, '.vscode', 'cmake-variants.json');
    const variantFileBackup = path.join(testEnv.projectFolder.location, '.vscode', 'cmake-variants.json.backup');
    await fs.rename(variantFile, variantFileBackup);
    expect(await fs.exists(variantFile)).to.be.false;

    // Set fake settings
    testEnv.config.updatePartial({
      defaultVariants: {
        buildType: {
          default: 'debug-label',
          choices: {
            'debug-label': {short: 'debug-label short', buildType: 'Debug'},
            'not-debug': {short: 'not-debug short', buildType: 'Release'}
          }
        },
        otherVariant: {
          default: 'option1',
          choices: {
            option1: {short: 'option1 short', env: {TEST_VARIANT_ENV: '0xCAFE'}},
            option2: {short: 'option2 short'}
          }
        }
      }
    });

    try {
      // Configure
      expect(await cmt.configure()).to.be.eq(0, '[variantEnv] configure failed');
      expect(testEnv.projectFolder.buildDirectory.isCMakeCachePresent).to.eql(true, 'expected cache not present');
      const cache = await CMakeCache.fromPath(await cmt.cachePath);

      const cacheEntry_ = cache.get('variantEnv');
      expect(cacheEntry_).to.not.be.eq(null, '[variantEnv] Cache entry was not present');
      const cacheEntry = cacheEntry_!;
      expect(cacheEntry.type).to.eq(api.CacheEntryType.String, '[variantEnv] unexpected cache entry type');
      expect(cacheEntry.key).to.eq('variantEnv', '[variantEnv] unexpected cache entry key name');
      expect(typeof cacheEntry.value).to.eq('string', '[variantEnv] unexpected cache entry value type');
      expect(cacheEntry.as<string>()).to.eq('0xCAFE', '[variantEnv] incorrect environment variable');
    } finally {
      // Restore the vairants file to before the test
      await fs.rename(variantFileBackup, variantFile);
    }
  }).timeout(100000);

  setup(async function(this: Mocha.IBeforeAndAfterContext) {
    this.timeout(100000);
    if (process.platform === 'win32')
      this.skip();

    testEnv = new DefaultEnvironment('test/extension-tests/successful-build/project-folder', 'build', 'output.txt');
    cmt = await CMakeTools.create(testEnv.vsContext, testEnv.wsContext);

    const kits = await kitsAvailableInWorkspaceDirectory(testEnv.projectFolder.location);
    const tc_kit = kits.find(k => k.name === 'Test Toolchain');
    expect(tc_kit).to.not.eq(undefined);

    // Set preferred generators
    testEnv.config.updatePartial({preferredGenerators: ['Unix Makefiles']});
    await cmt.setKit(tc_kit!);

    testEnv.projectFolder.buildDirectory.clear();
  });

  test('Passing env-vars to CMake AND to the compiler', async () => {
    // Set fake settings
    testEnv.config.updatePartial({environment: {_ENV: '${workspaceRootFolderName}'}});

    // Configure
    expect(await cmt.configure()).to.be.eq(0, '[environment] configure failed');
    expect(testEnv.projectFolder.buildDirectory.isCMakeCachePresent).to.eql(true, 'expected cache not present');
    const cache = await CMakeCache.fromPath(await cmt.cachePath);

    const cacheEntry = cache.get('environment') as api.CacheEntry;
    expect(cacheEntry.type).to.eq(api.CacheEntryType.String, '[environment] unexpected cache entry type');
    expect(cacheEntry.key).to.eq('environment', '[environment] unexpected cache entry key name');
    expect(cacheEntry.as<string>())
        .to.eq(path.basename(testEnv.projectFolder.location), '[environment] substitution incorrect');
    expect(typeof cacheEntry.value).to.eq('string', '[environment] unexpected cache entry value type');

    // Build
    expect(await cmt.build()).to.be.eq(0, '[environment] build failed');
    const result = await testEnv.result.getResultAsJson();
    expect(result['env']).to.eq(path.basename(testEnv.projectFolder.location), '[environment] substitution incorrect');
  }).timeout(100000);

  test('Windows shell splitting', () => {
    const pairs: [string, string[]][] = [
      ['foo', ['foo']],
      ['foo bar', ['foo', 'bar']],
      ['"foo" bar', ['foo', 'bar']],
      ['', []],
      ['""', ['']],
      [`'quote arg'`, [`'quote`, `arg'`]],
      ['Something    ', ['Something']],
      ['"   fail"', ['   fail']],
      ['    arg', ['arg']],
      ['foo     bar', ['foo', 'bar']],
      ['"C:\\Program Files" something', ['C:\\Program Files', 'something']],
      ['foo "" bar', ['foo', '', 'bar']],
    ];

    for (const [cmd, expected] of pairs) {
      expect(splitWin(cmd)).to.eql(expected, `Bad parse for string: ${cmd}`);
    }
  });

  test('Check substitution for "buildType"', async () => {
    // Set fake settings
    testEnv.config.updatePartial({configureSettings: {buildType: '${buildType}'}});

    // Configure
    expect(await cmt.configure()).to.be.eq(0, '[buildType] configure failed');
    expect(testEnv.projectFolder.buildDirectory.isCMakeCachePresent).to.eql(true, 'expected cache not present');
    const cache = await CMakeCache.fromPath(await cmt.cachePath);

    const cacheEntry = cache.get('buildType') as api.CacheEntry;
    expect(cacheEntry.type).to.eq(api.CacheEntryType.String, '[buildType] unexpected cache entry type');
    expect(cacheEntry.key).to.eq('buildType', '[buildType] unexpected cache entry key name');
    expect(cacheEntry.as<string>()).to.eq('Debug', '[buildType] substitution incorrect');
    expect(typeof cacheEntry.value).to.eq('string', '[buildType] unexpected cache entry value type');
  }).timeout(100000);

       async function(this: ITestCallbackContext) {
         // Select compiler build node dependent
         const os_compilers: {[osName: string]: {kitLabel: RegExp, compiler: string}[]} = {
           linux: [{kitLabel: /^GCC \d/, compiler: 'GNU'}, {kitLabel: /^Clang \d/, compiler: 'Clang'}],
           win32: [{kitLabel: /^GCC \d/, compiler: 'GNU'}, {kitLabel: /^VisualStudio/, compiler: 'MSVC'}]
         };
         if (!(workername in os_compilers))
           this.skip();
         const compiler = os_compilers[workername];

         testEnv.kitSelection.defaultKitLabel = compiler[0].kitLabel;
         await cmt.setKit(await getMatchingSystemKit(compiler[0].kitLabel));
         await cmt.build();

         testEnv.kitSelection.defaultKitLabel = compiler[1].kitLabel;
         await cmt.setKit(await getMatchingSystemKit(compiler[1].kitLabel));
         await cmt.build();

         const result1 = await testEnv.result.getResultAsJson();
         expect(result1['compiler']).to.eql(compiler[1].compiler);
       })