Get some tests running using the analysis driver

pkg/analysis_server/test/context_manager_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.context.directory.manager;
 
 import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
+import 'package:analysis_server/src/utilities/null_string_sink.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/context/builder.dart';
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/services/lint.dart';
+import 'package:analyzer/src/summary/summary_file_builder.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:linter/src/plugin/linter_plugin.dart';
 import 'package:linter/src/rules.dart';
 import 'package:linter/src/rules/avoid_as.dart';
 import 'package:path/path.dart' as path;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'mock_sdk.dart';
 import 'mocks.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AbstractContextManagerTest);
     defineReflectiveTests(ContextManagerWithNewOptionsTest);
+    defineReflectiveTests(ContextManagerWithNewOptionsTest_Driver);
     defineReflectiveTests(ContextManagerWithOldOptionsTest);
+    defineReflectiveTests(ContextManagerWithOldOptionsTest_Driver);
   });
 }
 
 @reflectiveTest
 class AbstractContextManagerTest extends ContextManagerTest {
   void test_contextsInAnalysisRoot_nestedContext() {
     String subProjPath = path.posix.join(projPath, 'subproj');
     Folder subProjFolder = resourceProvider.newFolder(subProjPath);
     resourceProvider.newFile(
         path.posix.join(subProjPath, 'pubspec.yaml'), 'contents');
@@ skipping 94 matching lines @@
 test_pack:lib/''');
     // Setup context.
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
     // Confirm that one context was created.
     var contexts =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contexts, isNotNull);
     expect(contexts.length, equals(1));
-    var context = contexts[0];
-    var source = context.sourceFactory.forUri('dart:foobar');
+    var source = sourceFactory.forUri('dart:foobar');
     expect(source, isNotNull);
     expect(source.fullName, '/my/proj/sdk_ext/entry.dart');
     // We can't find dart:core because we didn't list it in our
     // embedded_libs map.
-    expect(context.sourceFactory.forUri('dart:core'), isNull);
+    expect(sourceFactory.forUri('dart:core'), isNull);
     // We can find dart:typed_data because we listed it in our
     // embedded_libs map.
-    expect(context.sourceFactory.forUri('dart:typed_data'), isNotNull);
+    expect(sourceFactory.forUri('dart:typed_data'), isNotNull);
   }
 
   test_ignoreFilesInPackagesFolder() {
     // create a context with a pubspec.yaml file
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     // create a file in the "packages" folder
     String filePath1 = path.posix.join(projPath, 'packages', 'file1.dart');
     resourceProvider.newFile(filePath1, 'contents');
     // "packages" files are ignored initially
@@ skipping 207 matching lines @@
         [projPath, '.packages'],
         r'''
 test_pack:lib/''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // Confirm that one context was created.
     var contexts =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contexts, isNotNull);
     expect(contexts.length, equals(1));
-    var context = contexts[0];
-    var source = context.sourceFactory.forUri('dart:foobar');
+    var source = sourceFactory.forUri('dart:foobar');
     expect(source.fullName, equals('/my/proj/sdk_ext/entry.dart'));
   }
 
   void test_setRoots_addFolderWithDartFile() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     var filePaths = callbacks.currentContextFilePaths[projPath];
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
     List<AnalysisContext> contextsInAnalysisRoot =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contextsInAnalysisRoot, hasLength(1));
     AnalysisContext context = contextsInAnalysisRoot[0];
     expect(context, isNotNull);
-    Source result = context.sourceFactory.forUri('package:foo/foo.dart');
+    Source result = sourceFactory.forUri('package:foo/foo.dart');
     expect(result, isNotNull);
     expect(result.exists(), isFalse);
   }
 
   void test_setRoots_addFolderWithDartFileInSubfolder() {
     String filePath = path.posix.join(projPath, 'foo', 'bar.dart');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     var filePaths = callbacks.currentContextFilePaths[projPath];
@@ skipping 532 matching lines @@
     String filePath = path.posix.join(projPath, 'lib', 'foo.dart');
     newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'foo:lib/');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     List<AnalysisContext> contextsInAnalysisRoot =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contextsInAnalysisRoot, hasLength(1));
     AnalysisContext context = contextsInAnalysisRoot[0];
     expect(context, isNotNull);
-    Source result = context.sourceFactory.forUri('package:foo/foo.dart');
+    Source result = sourceFactory.forUri('package:foo/foo.dart');
     expect(result.fullName, filePath);
   }
 
   void test_setRoots_pathContainsDotFile() {
     // If the path to a file (relative to the context root) contains a folder
     // whose name begins with '.', then the file is ignored.
     String project = '/project';
     String fileA = '$project/foo.dart';
     String fileB = '$project/.pub/bar.dart';
     resourceProvider.newFile(fileA, '');
@@ skipping 765 matching lines @@
       '**/*.${AnalysisEngine.SUFFIX_HTML}',
       '**/*.${AnalysisEngine.SUFFIX_HTM}',
       '**/${AnalysisEngine.ANALYSIS_OPTIONS_FILE}',
       '**/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}'
     ];
     return patterns
         .map((pattern) => new Glob(path.posix.separator, pattern))
         .toList();
   }
 
-  List<ErrorProcessor> get errorProcessors =>
-      callbacks.currentContext.analysisOptions.errorProcessors;
+  AnalysisOptions get analysisOptions => callbacks.analysisOptions;
 
-  List<Linter> get lints => getLints(callbacks.currentContext);
+  bool get enableAnalysisDriver => false;
 
-  AnalysisOptions get options => callbacks.currentContext.analysisOptions;
+  List<ErrorProcessor> get errorProcessors => analysisOptions.errorProcessors;
+
+  List<Linter> get lints => analysisOptions.lintRules;
+
+  SourceFactory get sourceFactory => callbacks.sourceFactory;
 
   Map<String, List<Folder>> get _currentPackageMap => _packageMap(projPath);
 
   void deleteFile(List<String> pathComponents) {
     String filePath = path.posix.joinAll(pathComponents);
     resourceProvider.deleteFile(filePath);
   }
 
+  /**
+   * TODO(brianwilkerson) This doesn't add the strong mode processor when using
+   * the new analysis driver.
+   */
   ErrorProcessor getProcessor(AnalysisError error) =>
-      ErrorProcessor.getProcessor(callbacks.currentContext, error);
+      callbacks.currentDriver == null
+          ? ErrorProcessor.getProcessor(callbacks.currentContext, error)
+          : errorProcessors.firstWhere((ErrorProcessor p) => p.appliesTo(error),
+              orElse: () => null);
 
   String newFile(List<String> pathComponents, [String content = '']) {
     String filePath = path.posix.joinAll(pathComponents);
     resourceProvider.newFile(filePath, content);
     return filePath;
   }
 
+  String newFileFromBytes(List<String> pathComponents, List<int> bytes) {
+    String filePath = path.posix.joinAll(pathComponents);
+    resourceProvider.newFileWithBytes(filePath, bytes);
+    return filePath;
+  }
+
   String newFolder(List<String> pathComponents) {
     String folderPath = path.posix.joinAll(pathComponents);
     resourceProvider.newFolder(folderPath);
     return folderPath;
   }
 
   void processRequiredPlugins() {
     List<Plugin> plugins = <Plugin>[];
     plugins.addAll(AnalysisEngine.instance.requiredPlugins);
     plugins.add(AnalysisEngine.instance.commandLinePlugin);
     plugins.add(AnalysisEngine.instance.optionsPlugin);
     plugins.add(linterPlugin);
     ExtensionManager manager = new ExtensionManager();
     manager.processPlugins(plugins);
 
     registerLintRules();
   }
 
   UriResolver providePackageResolver(Folder folder) => packageResolver;
 
   void setUp() {
     processRequiredPlugins();
     resourceProvider = new MemoryResourceProvider();
+    resourceProvider.newFolder(projPath);
     packageMapProvider = new MockPackageMapProvider();
     // Create an SDK in the mock file system.
-    new MockSdk(resourceProvider: resourceProvider);
+    new MockSdk(generateSummaryFiles: true, resourceProvider: resourceProvider);
     DartSdkManager sdkManager = new DartSdkManager('/', false);
     manager = new ContextManagerImpl(
         resourceProvider,
         sdkManager,
         providePackageResolver,
         packageMapProvider,
         analysisFilesGlobs,
         InstrumentationService.NULL_SERVICE,
         new AnalysisOptionsImpl(),
-        false);
-    callbacks = new TestContextManagerCallbacks(resourceProvider);
+        enableAnalysisDriver);
+    PerformanceLog logger = new PerformanceLog(new NullStringSink());
+    AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(logger);
+    callbacks =
+        new TestContextManagerCallbacks(resourceProvider, logger, scheduler);
     manager.callbacks = callbacks;
-    resourceProvider.newFolder(projPath);
   }
 
   /**
    * Verify that package URI's for source files in [path] will be resolved
    * using a package root matching [expectation].
    */
   void _checkPackageRoot(String path, expectation) {
     // TODO(brianwilkerson) Figure out how to test this. Possibly by comparing
     // the contents of the package map (although that approach doesn't work at
     // the moment).
 //    FolderDisposition disposition = callbacks.currentContextDispositions[path];
 //    expect(disposition.packageRoot, expectation);
     // TODO(paulberry): we should also verify that the package map itself is
     // correct.  See dartbug.com/23909.
   }
 
   Map<String, List<Folder>> _packageMap(String contextPath) {
     Folder folder = resourceProvider.getFolder(contextPath);
     return manager.folderMap[folder]?.sourceFactory?.packageMap;
   }
 }
 
 @reflectiveTest
 class ContextManagerWithNewOptionsTest extends ContextManagerWithOptionsTest {
   String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
 }
 
 @reflectiveTest
+class ContextManagerWithNewOptionsTest_Driver
+    extends ContextManagerWithNewOptionsTest {
+  bool get enableAnalysisDriver => true;
+
+  @failingTest
+  test_analysis_options_file_delete() async {
+    // It appears that this fails because we are not correctly updating the
+    // analysis options in the driver when the file is removed.
+    return super.test_analysis_options_file_delete();
+  }
+
+  @failingTest
+  test_analysis_options_file_delete_with_embedder() async {
+    // This fails because the ContextBuilder doesn't pick up the strongMode
+    // flag from the embedder.yaml file.
+    return super.test_analysis_options_file_delete_with_embedder();
+  }
+
+  @failingTest
+  test_embedder_options() async {
+    // This fails because the ContextBuilder doesn't pick up the strongMode
+    // flag from the embedder.yaml file.
+    return super.test_embedder_options();
+  }
+
+  @failingTest
+  test_optionsFile_update_strongMode() async {
+    // It appears that this fails because we are not correctly updating the
+    // analysis options in the driver when the file is modified.
+    //return super.test_optionsFile_update_strongMode();
+    // After a few other changes, the test now times out on my machine, so I'm
+    // disabling it in order to prevent it from being flaky.
+    fail('Test times out');
+  }
+
+  @failingTest
+  test_path_filter_analysis_option() async {
+    // This fails because we're not analyzing the analyis options file.
+    return super.test_path_filter_analysis_option();
+  }
+}
+
+@reflectiveTest
 class ContextManagerWithOldOptionsTest extends ContextManagerWithOptionsTest {
   String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_FILE;
 }
 
+@reflectiveTest
+class ContextManagerWithOldOptionsTest_Driver
+    extends ContextManagerWithOldOptionsTest {
+  bool get enableAnalysisDriver => true;
+
+  @failingTest
+  test_analysis_options_file_delete() async {
+    // It appears that this fails because we are not correctly updating the
+    // analysis options in the driver when the file is removed.
+    return super.test_analysis_options_file_delete();
+  }
+
+  @failingTest
+  test_analysis_options_file_delete_with_embedder() async {
+    // This fails because the ContextBuilder doesn't pick up the strongMode
+    // flag from the embedder.yaml file.
+    return super.test_analysis_options_file_delete_with_embedder();
+  }
+
+  @failingTest
+  test_embedder_options() async {
+    // This fails because the ContextBuilder doesn't pick up the strongMode
+    // flag from the embedder.yaml file.
+    return super.test_embedder_options();
+  }
+
+  @failingTest
+  test_optionsFile_update_strongMode() async {
+    // It appears that this fails because we are not correctly updating the
+    // analysis options in the driver when the file is modified.
+    //return super.test_optionsFile_update_strongMode();
+    // After a few other changes, the test now times out on my machine, so I'm
+    // disabling it in order to prevent it from being flaky.
+    fail('Test times out');
+  }
+
+  @failingTest
+  test_path_filter_analysis_option() async {
+    // This fails because we're not analyzing the analyis options file.
+    return super.test_path_filter_analysis_option();
+  }
+}
+
 abstract class ContextManagerWithOptionsTest extends ContextManagerTest {
   String get optionsFileName;
 
   test_analysis_options_file_delete() async {
     // Setup analysis options
     newFile(
         [projPath, optionsFileName],
         r'''
 embedded_libs:
   "dart:foobar": "../sdk_ext/entry.dart"
 analyzer:
   language:
     enableStrictCallChecks: true
   errors:
     unused_local_variable: false
 linter:
   rules:
     - camel_case_types
 ''');
 
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
     // Verify options were set.
     expect(errorProcessors, hasLength(1));
     expect(lints, hasLength(1));
-    expect(options.enableStrictCallChecks, isTrue);
+    expect(analysisOptions.enableStrictCallChecks, isTrue);
 
     // Remove options.
     deleteFile([projPath, optionsFileName]);
     await pumpEventQueue();
 
     // Verify defaults restored.
     expect(errorProcessors, isEmpty);
     expect(lints, isEmpty);
-    expect(options.enableStrictCallChecks, isFalse);
+    expect(analysisOptions.enableStrictCallChecks, isFalse);
   }
 
   test_analysis_options_file_delete_with_embedder() async {
     // Setup _embedder.yaml.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile(
         [libPath, '_embedder.yaml'],
         r'''
 analyzer:
   strong-mode: true
@@ skipping 22 matching lines @@
 linter:
   rules:
     - camel_case_types
 ''');
 
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
     // Verify options were set.
-    expect(options.enableStrictCallChecks, isTrue);
-    expect(options.strongMode, isTrue);
+    expect(analysisOptions.enableStrictCallChecks, isTrue);
+    expect(analysisOptions.strongMode, isTrue);
     expect(errorProcessors, hasLength(2));
     expect(lints, hasLength(2));
 
     // Remove options.
     deleteFile([projPath, optionsFileName]);
     await pumpEventQueue();
 
     // Verify defaults restored.
-    expect(options.enableStrictCallChecks, isFalse);
+    expect(analysisOptions.enableStrictCallChecks, isFalse);
     expect(lints, hasLength(1));
     expect(lints.first, new isInstanceOf<AvoidAs>());
     expect(errorProcessors, hasLength(1));
     expect(getProcessor(missing_return).severity, isNull);
   }
 
   test_analysis_options_include() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
@@ skipping 16 matching lines @@
   errors:
     unused_local_variable: false
 linter:
   rules:
     - camel_case_types
 ''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
     // Verify options were set.
-    expect(options.enableStrictCallChecks, isTrue);
+    expect(analysisOptions.enableStrictCallChecks, isTrue);
     expect(errorProcessors, hasLength(1));
     expect(lints, hasLength(1));
     expect(lints[0].name, 'camel_case_types');
   }
 
   test_analysis_options_parse_failure() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     String sdkExtPath = newFolder([projPath, 'sdk_ext']);
@@ skipping 11 matching lines @@
 
     // No error means success.
   }
 
   test_embedder_options() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     String sdkExtPath = newFolder([projPath, 'sdk_ext']);
     newFile([projPath, 'test', 'test.dart']);
     newFile([sdkExtPath, 'entry.dart']);
+    List<int> bytes = new SummaryBuilder([], null, true).build();
+    newFileFromBytes([projPath, 'sdk.ds'], bytes);
     // Setup _embedder.yaml.
     newFile(
         [libPath, '_embedder.yaml'],
         r'''
 embedded_libs:
   "dart:foobar": "../sdk_ext/entry.dart"
 analyzer:
   strong-mode: true
   language:
     enableSuperMixins: true
@@ skipping 27 matching lines @@
 
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
     // Confirm that one context was created.
     var contexts =
         manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
     expect(contexts, isNotNull);
     expect(contexts, hasLength(1));
-    var context = contexts[0];
 
     // Verify options.
     // * from `_embedder.yaml`:
-    expect(context.analysisOptions.strongMode, isTrue);
-    expect(context.analysisOptions.enableSuperMixins, isTrue);
+    expect(analysisOptions.strongMode, isTrue);
+    expect(analysisOptions.enableSuperMixins, isTrue);
     // * from analysis options:
-    expect(context.analysisOptions.enableStrictCallChecks, isTrue);
+    expect(analysisOptions.enableStrictCallChecks, isTrue);
 
     // * verify tests are excluded
     expect(
         callbacks.currentContextFilePaths[projPath].keys,
         unorderedEquals(
             ['/my/proj/sdk_ext/entry.dart', '/my/proj/$optionsFileName']));
 
     // Verify filter setup.
     expect(errorProcessors, hasLength(2));
 
     // * (embedder.)
     expect(getProcessor(missing_return).severity, isNull);
 
     // * (options.)
     expect(getProcessor(unused_local_variable).severity, isNull);
 
     // Verify lints.
     var lintNames = lints.map((lint) => lint.name);
 
     expect(
         lintNames,
         unorderedEquals(
             ['avoid_as' /* embedder */, 'camel_case_types' /* options */]));
 
     // Sanity check embedder libs.
-    var source = context.sourceFactory.forUri('dart:foobar');
+    var source = sourceFactory.forUri('dart:foobar');
     expect(source, isNotNull);
     expect(source.fullName, '/my/proj/sdk_ext/entry.dart');
   }
 
   test_error_filter_analysis_option() async {
     // Create files.
     newFile(
         [projPath, optionsFileName],
         r'''
 analyzer:
@@ skipping 75 matching lines @@
     resourceProvider.newFile(
         '$projPath/$optionsFileName',
         r'''
 analyzer:
   strong-mode: false
 ''');
     // Create the context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
-    AnalysisContext context = manager.getContextFor(projPath);
-    Source testSource = context.getSourcesWithFullName(file.path).single;
+    if (enableAnalysisDriver) {
+      AnalysisResult result =
+          await callbacks.currentDriver.getResult(file.path);
 
-    // Not strong mode - both in the context and the SDK context.
-    {
-      AnalysisContext sdkContext = context.sourceFactory.dartSdk.context;
-      expect(context.analysisOptions.strongMode, isFalse);
+      // Not strong mode - both in the context and the SDK context.
+      AnalysisContext sdkContext = sourceFactory.dartSdk.context;
+      expect(analysisOptions.strongMode, isFalse);
+      expect(sdkContext.analysisOptions.strongMode, isFalse);
+      expect(result.errors, isEmpty);
+    } else {
+      AnalysisContext context = manager.getContextFor(projPath);
+      Source testSource = context.getSourcesWithFullName(file.path).single;
+
+      // Not strong mode - both in the context and the SDK context.
+      AnalysisContext sdkContext = sourceFactory.dartSdk.context;
+      expect(analysisOptions.strongMode, isFalse);
       expect(sdkContext.analysisOptions.strongMode, isFalse);
       expect(context.computeErrors(testSource), isEmpty);
     }
 
     // Update the options file - turn on 'strong-mode'.
     resourceProvider.updateFile(
         '$projPath/$optionsFileName',
         r'''
 analyzer:
   strong-mode: true
 ''');
     await pumpEventQueue();
 
     // Strong mode - both in the context and the SDK context.
-    {
-      AnalysisContext context = manager.getContextFor(projPath);
-      AnalysisContext sdkContext = context.sourceFactory.dartSdk.context;
-      expect(context.analysisOptions.strongMode, isTrue);
+    if (enableAnalysisDriver) {
+      AnalysisResult result =
+          await callbacks.currentDriver.getResult(file.path);
+
+      // Not strong mode - both in the context and the SDK context.
+      AnalysisContext sdkContext = sourceFactory.dartSdk.context;
+      expect(analysisOptions.strongMode, isTrue);
       expect(sdkContext.analysisOptions.strongMode, isTrue);
       // The code is strong-mode clean.
       // Verify that TypeSystem was reset.
+      expect(result.errors, isEmpty);
+    } else {
+      AnalysisContext context = manager.getContextFor(projPath);
+      Source testSource = context.getSourcesWithFullName(file.path).single;
+      AnalysisContext sdkContext = sourceFactory.dartSdk.context;
+      expect(analysisOptions.strongMode, isTrue);
+      expect(sdkContext.analysisOptions.strongMode, isTrue);
+      // The code is strong-mode clean.
+      // Verify that TypeSystem was reset.
       expect(context.computeErrors(testSource), isEmpty);
     }
   }
 
   test_path_filter_analysis_option() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile([libPath, 'nope.dart']);
     String sdkExtPath = newFolder([projPath, 'sdk_ext']);
     newFile([sdkExtPath, 'entry.dart']);
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Setup analysis options file with ignore list.
     newFile(
         [projPath, optionsFileName],
         r'''
 analyzer:
   exclude:
     - lib/nope.dart
     - 'sdk_ext/**'
 ''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
+
     // Verify that analysis options was parsed and the ignore patterns applied.
-    Map<String, int> fileTimestamps =
-        callbacks.currentContextFilePaths[projPath];
-    expect(fileTimestamps, isNotEmpty);
-    List<String> files = fileTimestamps.keys.toList();
-    expect(
-        files,
-        unorderedEquals(
-            ['/my/proj/lib/main.dart', '/my/proj/$optionsFileName']));
+    Folder projectFolder = resourceProvider.newFolder(projPath);
+    if (enableAnalysisDriver) {
+      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, hasLength(1));
+      AnalysisDriver driver = drivers[0];
+      expect(
+          driver.addedFiles,
+          unorderedEquals(
+              ['/my/proj/lib/main.dart', '/my/proj/$optionsFileName']));
+    } else {
+      Map<String, int> fileTimestamps =
+          callbacks.currentContextFilePaths[projPath];
+      expect(fileTimestamps, isNotEmpty);
+      List<String> files = fileTimestamps.keys.toList();
+      expect(
+          files,
+          unorderedEquals(
+              ['/my/proj/lib/main.dart', '/my/proj/$optionsFileName']));
+    }
   }
 
   test_path_filter_child_contexts_option() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile(
         [libPath, 'pubspec.yaml'],
         r'''
 name: foobar
@@ skipping 11 matching lines @@
         [projPath, optionsFileName],
         r'''
 analyzer:
   exclude:
     - 'other_lib'
 ''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // Verify that the context in other_lib wasn't created and that the
     // context in lib was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts.length, 2);
-    expect(contexts[0].name, equals('/my/proj'));
-    expect(contexts[1].name, equals('/my/proj/lib'));
+    Folder projectFolder = resourceProvider.newFolder(projPath);
+    if (enableAnalysisDriver) {
+      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, hasLength(2));
+      expect(drivers[0].name, equals('proj'));
+      expect(drivers[1].name, equals('lib'));
+    } else {
+      var contexts =
+          manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+      expect(contexts.length, 2);
+      expect(contexts[0].name, equals('/my/proj'));
+      expect(contexts[1].name, equals('/my/proj/lib'));
+    }
   }
 
   test_path_filter_recursive_wildcard_child_contexts_option() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile(
         [libPath, 'pubspec.yaml'],
         r'''
   name: foobar
   ''');
     String otherLibPath = newFolder([projPath, 'other_lib']);
     newFile([otherLibPath, 'entry.dart']);
     newFile(
         [otherLibPath, 'pubspec.yaml'],
         r'''
   name: other_lib
   ''');
     // Setup analysis options file with ignore list that ignores 'other_lib'
     // and all descendants.
     newFile(
         [projPath, optionsFileName],
         r'''
 analyzer:
   exclude:
     - 'other_lib/**'
   ''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
+
     // Verify that the context in other_lib wasn't created and that the
     // context in lib was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts.length, 2);
-    expect(contexts[0].name, equals('/my/proj'));
-    expect(contexts[1].name, equals('/my/proj/lib'));
+    Folder projectFolder = resourceProvider.newFolder(projPath);
+    if (enableAnalysisDriver) {
+      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, hasLength(2));
+      expect(drivers[0].name, equals('proj'));
+      expect(drivers[1].name, equals('lib'));
+    } else {
+      var contexts = manager.contextsInAnalysisRoot(projectFolder);
+      expect(contexts.length, 2);
+      expect(contexts[0].name, equals('/my/proj'));
+      expect(contexts[1].name, equals('/my/proj/lib'));
+    }
   }
 
   test_path_filter_wildcard_child_contexts_option() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile(
         [libPath, 'pubspec.yaml'],
         r'''
 name: foobar
 ''');
     String otherLibPath = newFolder([projPath, 'other_lib']);
     newFile([otherLibPath, 'entry.dart']);
     newFile(
         [otherLibPath, 'pubspec.yaml'],
         r'''
 name: other_lib
 ''');
     // Setup analysis options file with ignore list that ignores 'other_lib'
     // and all immediate children.
     newFile(
         [projPath, optionsFileName],
         r'''
 analyzer:
   exclude:
     - 'other_lib/*'
 ''');
-    // Setup context.
+    // Setup context / driver.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    // Verify that the context in other_lib wasn't created and that the
-    // context in lib was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts.length, 2);
-    expect(contexts[0].name, equals('/my/proj'));
-    expect(contexts[1].name, equals('/my/proj/lib'));
+
+    Folder projectFolder = resourceProvider.newFolder(projPath);
+    if (enableAnalysisDriver) {
+      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, hasLength(2));
+      expect(drivers[0].name, equals('proj'));
+      expect(drivers[1].name, equals('lib'));
+    } else {
+      // Verify that the context in other_lib wasn't created and that the
+      // context in lib was created.
+      var contexts = manager.contextsInAnalysisRoot(projectFolder);
+      expect(contexts, hasLength(2));
+      expect(contexts[0].name, equals('/my/proj'));
+      expect(contexts[1].name, equals('/my/proj/lib'));
+    }
   }
 
   void test_setRoots_nested_excludedByOuter() {
     String project = '/project';
     String projectPubspec = '$project/pubspec.yaml';
     String example = '$project/example';
     String examplePubspec = '$example/pubspec.yaml';
     // create files
     resourceProvider.newFile(projectPubspec, 'name: project');
     resourceProvider.newFile(examplePubspec, 'name: example');
@@ skipping 66 matching lines @@
         [projPath, optionsFileName],
         r'''
 analyzer:
   strong-mode: true
 ''');
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // Verify that analysis options was parsed and strong-mode set.
-    Map<String, int> fileTimestamps =
-        callbacks.currentContextFilePaths[projPath];
-    expect(fileTimestamps, isNotEmpty);
-    expect(callbacks.currentContext.analysisOptions.strongMode, true);
+    expect(analysisOptions.strongMode, true);
   }
 }
 
 class TestContextManagerCallbacks extends ContextManagerCallbacks {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
   /**
    * The analysis context that was created.
    */
   AnalysisContext currentContext;
 
   /**
+   * The analysis driver that was created.
+   */
+  AnalysisDriver currentDriver;
+
+  /**
    * Map from context to the timestamp when the context was created.
    */
   Map<String, int> currentContextTimestamps = <String, int>{};
 
   /**
    * Map from context to (map from file path to timestamp of last event).
    */
   final Map<String, Map<String, int>> currentContextFilePaths =
       <String, Map<String, int>>{};
 
   /**
    * A map from the paths of contexts to a set of the sources that should be
    * explicitly analyzed in those contexts.
    */
   final Map<String, Set<Source>> currentContextSources =
       <String, Set<Source>>{};
 
   /**
    * Resource provider used for this test.
    */
   final ResourceProvider resourceProvider;
 
   /**
+   * The logger used by the scheduler and the driver.
+   */
+  final PerformanceLog logger;
+
+  /**
+   * The scheduler used by the driver.
+   */
+  final AnalysisDriverScheduler scheduler;
+
+  /**
    * The list of `flushedFiles` in the last [removeContext] invocation.
    */
   List<String> lastFlushedFiles;
 
-  TestContextManagerCallbacks(this.resourceProvider);
+  TestContextManagerCallbacks(
+      this.resourceProvider, this.logger, this.scheduler);
+
+  /**
+   * Return the current set of analysis options.
+   */
+  AnalysisOptions get analysisOptions => currentDriver == null
+      ? currentContext.analysisOptions
+      : currentDriver.analysisOptions;
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
+  /**
+   * Return the current source factory.
+   */
+  SourceFactory get sourceFactory => currentDriver == null
+      ? currentContext.sourceFactory
+      : currentDriver.sourceFactory;
+
   @override
   AnalysisDriver addAnalysisDriver(Folder folder, AnalysisOptions options) {
-    // TODO: implement addAnalysisDriver
-    throw new UnimplementedError();
+    String path = folder.path;
+    expect(currentContextPaths, isNot(contains(path)));
+    currentContextTimestamps[path] = now;
+
+    ContextBuilder builder =
+        createContextBuilder(folder, options, useSummaries: true);
+    AnalysisContext context = builder.buildContext(folder.path);
+    SourceFactory sourceFactory = context.sourceFactory;
+    AnalysisOptions analysisOptions = context.analysisOptions;
+    context.dispose();
+
+    currentDriver = new AnalysisDriver(
+        scheduler,
+        logger,
+        resourceProvider,
+        new MemoryByteStore(),
+        new FileContentOverlay(),
+        sourceFactory,
+        analysisOptions);
+    currentDriver.name = folder.shortName;
+    currentDriver.exceptions.listen((ExceptionResult result) {
+      AnalysisEngine.instance.logger
+          .logError('Analysis failed: ${result.path}', result.exception);
+    });
+    return currentDriver;
   }
 
   @override
   AnalysisContext addContext(Folder folder, AnalysisOptions options) {
     String path = folder.path;
     expect(currentContextPaths, isNot(contains(path)));
     currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
     currentContextSources[path] = new HashSet<Source>();
 
     ContextBuilder builder = createContextBuilder(folder, options);
     currentContext = builder.buildContext(folder.path);
     return currentContext;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
-    Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
-    Set<Source> sources = currentContextSources[contextFolder.path];
+    if (currentDriver != null) {
+      changeSet.addedSources.forEach((source) {
+        currentDriver.addFile(source.fullName);
+      });
+      changeSet.changedSources.forEach((source) {
+        currentDriver.changeFile(source.fullName);
+      });
+      changeSet.removedSources.forEach((source) {
+        currentDriver.removeFile(source.fullName);
+      });
+    } else {
+      Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
+      Set<Source> sources = currentContextSources[contextFolder.path];
 
-    for (Source source in changeSet.addedSources) {
-      expect(filePaths, isNot(contains(source.fullName)));
-      filePaths[source.fullName] = now;
-      sources.add(source);
+      for (Source source in changeSet.addedSources) {
+        expect(filePaths, isNot(contains(source.fullName)));
+        filePaths[source.fullName] = now;
+        sources.add(source);
+      }
+      for (Source source in changeSet.removedSources) {
+        expect(filePaths, contains(source.fullName));
+        filePaths.remove(source.fullName);
+        sources.remove(source);
+      }
+      for (Source source in changeSet.changedSources) {
+        expect(filePaths, contains(source.fullName));
+        filePaths[source.fullName] = now;
+      }
+
+      currentContext.applyChanges(changeSet);
     }
-    for (Source source in changeSet.removedSources) {
-      expect(filePaths, contains(source.fullName));
-      filePaths.remove(source.fullName);
-      sources.remove(source);
-    }
-    for (Source source in changeSet.changedSources) {
-      expect(filePaths, contains(source.fullName));
-      filePaths[source.fullName] = now;
-    }
-
-    currentContext.applyChanges(changeSet);
   }
 
   @override
   void applyFileRemoved(AnalysisDriver driver, String file) {
-    throw new StateError('Unexpected invocation of applyFileRemoved');
+    driver.removeFile(file);
   }
 
   void assertContextFiles(String contextPath, List<String> expectedFiles) {
     var actualFiles = currentContextFilePaths[contextPath].keys;
     expect(actualFiles, unorderedEquals(expectedFiles));
   }
 
   void assertContextPaths(List<String> expected) {
     expect(currentContextPaths, unorderedEquals(expected));
   }
 
   @override
   void computingPackageMap(bool computing) {
     // Do nothing.
   }
 
   @override
-  ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options) {
-    DartSdkManager sdkManager = new DartSdkManager('/', false);
+  ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options,
+      {bool useSummaries = false}) {
+    DartSdkManager sdkManager = new DartSdkManager('/', useSummaries);
     ContextBuilderOptions builderOptions = new ContextBuilderOptions();
     builderOptions.defaultOptions = options;
     ContextBuilder builder = new ContextBuilder(
         resourceProvider, sdkManager, new ContentCache(),
         options: builderOptions);
     return builder;
   }
 
   @override
   void moveContext(Folder from, Folder to) {
@@ skipping 39 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }