task('test', [':test:build'], () => {
  let patternRoot = join(packagesDir, '**/*');
  // Load karma not outside. Karma pollutes Promise with a different implementation.
  let karma = require('karma');

  // Configure the Karma server and override the autoWatch and singleRun just in case.
  let server = new karma.Server({
    configFile: join(projectDir, 'test/karma.conf.js'),
    autoWatch: false,
    singleRun: false
  });

  // Refreshes Karma's file list and schedules a test run.
  // Tests will only run if TypeScript compilation was successful.
  let runTests = (err?: Error) => {
    if (!err) {
      server.refreshFiles().then(() => server._injector.get('executor').schedule());
    }
  };

  // Boot up the test server and run the tests whenever a new browser connects.
  server.start();
  server.on('browser_register', () => runTests());

  // Whenever a file change has been recognized, rebuild and re-run the tests.
  watch(patternRoot + '.+(ts|scss|html)', () => runSequence(':test:build', runTests));
});

 return new Promise((resolve, reject) => {
     const server = new karma.Server(config);
     server.on("run_complete", (browsers, results) => {
         resolve(results);
     });
     server.start();
 });

gulp.task('test', [':test:deps'], () => {
  let patternRoot = path.join(COMPONENTS_DIR, '**/*');

  // Configure the Karma server and override the autoWatch and singleRun just in case.
  let server = new karma.Server({
    configFile: path.join(PROJECT_ROOT, 'test/karma.conf.js'),
    autoWatch: false,
    singleRun: false
  });

  // Refreshes Karma's file list and schedules a test run.
  // Tests will only run if TypeScript compilation was successful.
  let runTests = (err?: Error) => {
    if (!err) {
      server.refreshFiles().then(() => server._injector.get('executor').schedule());
    }
  };

  // Boot up the test server and run the tests whenever a new browser connects.
  server.start();
  server.on('browser_register', () => runTests());

  // Watch for file changes, rebuild and run the tests.
  gulp.watch(patternRoot + '.ts', () => runSequence(':build:components:ts:spec', runTests));
  gulp.watch(patternRoot + '.scss', () => runSequence(':build:components:scss', runTests));
  gulp.watch(patternRoot + '.html', () => runSequence(':build:components:assets', runTests));
});

    protected init(cb: any) {
        const karma = require('karma')

        const server = new karma.Server(
            options,
            this.finish.bind(this, cb)
        )

        server.start()

        cb()
    }

  return new Promise<number>(resolve => {
    const server = new Server(karmaConfig, exitCode => {
      debug(`Karma finished.`);
      if (sauceConnectProcess) {
        debug(`Tries to close Sauce Connect.`);
        sauceConnectProcess.close(() => {
          debug(`Closed Sauce Connect.`);
          resolve(exitCode);
        });
      } else {
        resolve(exitCode);
      }
    });

    debug(`Start Karma.`);
    server.start();
  });

 return new Promise<boolean>((resolve, reject) => {
     const karmaServer = new karma.Server({
         port: 9876,
         configFile: process.cwd() + '/karma.conf.js',
         singleRun: true,
         client: {
             host,
             port,
             baseURL: `http://${host}:${port}`,
             mainModule
         }
     }, exitCode => {
         console.log(`Karma server finished with exit code ${exitCode}`);
     });
     karmaServer.on('run_complete', (browsers, result) => {
         resolve(!result.error)
     });
     karmaServer.start();
 });

            return new Promise<boolean>((resolve, reject) => {

                const karmaServer = new karma.Server({
                    port: karmaPort,
                    configFile: process.cwd() + '/karma.conf.js',
                    singleRun: true,
                    browserNoActivityTimeout: 100000,
                    client: {
                        baseURL: `http://${host}:${port}${basePath}`,
                        mainModule
                    }
                }, exitCode => {
                    console.log(`Karma server finished with exit code ${exitCode}`);
                });
                karmaServer.on('run_complete', (browsers, result) => {
                    if(result.exitCode === 0) {
                        resolve(!result.error);
                    } else {
                        reject(`Karma exited with code ${result.exitCode}`);
                    }
                });
                karmaServer.start();
            });

  return () => {
    const patternRoot = join(buildConfig.packagesDir, '**/*');
    // Note: Karma shouldn't be required from the outside, because it
    // pollutes the global Promise with a custom implementation.
    const karma = require('karma');

    // Configure the Karma server and override the autoWatch and singleRun just in case.
    const server = new karma.Server({...defaultOptions, ...options});

    // Refreshes Karma's file list and schedules a test run.
    // Tests will only run if TypeScript compilation was successful.
    const runTests = (error?: Error) => {
      if (!error) {
        server.refreshFiles().then(() => server._injector.get('executor').schedule());
      }
    };

    // Boot up the test server and run the tests whenever a new browser connects.
    server.start();
    server.on('browser_register', () => runTests());

    // Whenever a file change has been recognized, rebuild and re-run the tests.
    watch(patternRoot + '.+(ts|scss|html)', () => runSequence(':test:build', runTests));
  };

 let runTests = (err?: Error) => {
   if (!err) {
     server.refreshFiles().then(() => server._injector.get('executor').schedule());
   }
 };

 let runTests = () => {
   server.refreshFiles().then(() => server._injector.get('executor').schedule());
 };