anchor.diff:        host: _kHosts[serverType],
         previewDart2: previewDart2,
         port: port,
  -      dillFilePath: dillFilePath,
  +      precompiledDillPath: precompiledDillPath,
       ),
     );
   }
  
positive.code:     return null;
    }
  
    String _getWebSocketUrl(HttpServer server) {
      return host.type == InternetAddressType.IP_V4
          ? 'ws://${host.address}:${server.port}'
  
negative.code: enum _TestResult { crashed, harnessBailed, testBailed }
  typedef Future<Null> _Finalizer();
  
  class _CompilationRequest {
    String path;
    Completer<String> result;
  
    _CompilationRequest(this.path, this.result);
  }
  
  // This class is a wrapper around compiler that allows multiple isolates to
  // enqueue compilation requests, but ensures only one compilation at a time.
  class _Compiler {
    _Compiler() {
      // Compiler maintains and updates single incremental dill file.
      // Incremental compilation requests done for each test copy that file away
      // for independent execution.
      final Directory outputDillDirectory = fs.systemTempDirectory
          .createTempSync('output_dill');
      final File outputDill = outputDillDirectory.childFile('output.dill');
  
      compilerController.stream.listen((_CompilationRequest request) async {
        final bool isEmpty = compilationQueue.isEmpty;
        compilationQueue.add(request);
        // Only trigger processing if queue was empty - i.e. no other requests
        // are currently being processed. This effectively enforces "one
        // compilation request at a time".
        if (isEmpty) {
          while (compilationQueue.isNotEmpty) {
            final _CompilationRequest request = compilationQueue.first;
            printTrace('Compiling ${request.path}');
            final String outputPath = await compiler.recompile(request.path,
              <String>[request.path],
              outputPath: outputDill.path,
            );
            // Copy output dill next to the source file.
            await outputDill.copy(request.path + '.dill');
            compiler.accept();
            compiler.reset();
            request.result.complete(outputPath);
            // Only remove now when we finished processing the element
            compilationQueue.removeAt(0);
          }
        }
      }, onDone: () {
        outputDillDirectory.deleteSync(recursive: true);
      });
  
      compiler = new ResidentCompiler(
          artifacts.getArtifactPath(Artifact.flutterPatchedSdkPath),
          packagesPath: PackageMap.globalPackagesPath);
    }
  
    final StreamController<_CompilationRequest> compilerController =
        new StreamController<_CompilationRequest>();
    final List<_CompilationRequest> compilationQueue = <_CompilationRequest>[];
    ResidentCompiler compiler;
  
    Future<String> compile(String mainDart) {
      final Completer<String> completer = new Completer<String>();
      compilerController.add(new _CompilationRequest(mainDart, completer));
      return completer.future;
    }
  }
  
  class _FlutterPlatform extends PlatformPlugin {
  