Add more tests of the 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';
@@ skipping 21 matching lines @@
 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(AbstractContextManagerTest_Driver);
     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');
     String subProjFilePath = path.posix.join(subProjPath, 'file.dart');
     resourceProvider.newFile(subProjFilePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // Make sure that there really are contexts for both the main project and
     // the subproject.
-    Folder projFolder = resourceProvider.getFolder(projPath);
-    ContextInfo projContextInfo = manager.getContextInfoFor(projFolder);
+    Folder projectFolder = resourceProvider.getFolder(projPath);
+    ContextInfo projContextInfo = manager.getContextInfoFor(projectFolder);
     expect(projContextInfo, isNotNull);
-    expect(projContextInfo.folder, projFolder);
+    expect(projContextInfo.folder, projectFolder);
     ContextInfo subProjContextInfo = manager.getContextInfoFor(subProjFolder);
     expect(subProjContextInfo, isNotNull);
     expect(subProjContextInfo.folder, subProjFolder);
-    expect(projContextInfo.context != subProjContextInfo.context, isTrue);
-    // Check that contextsInAnalysisRoot() works.
-    List<AnalysisContext> contexts = manager.contextsInAnalysisRoot(projFolder);
-    expect(contexts, hasLength(2));
-    expect(contexts, contains(projContextInfo.context));
-    expect(contexts, contains(subProjContextInfo.context));
+    if (enableAnalysisDriver) {
+      expect(projContextInfo.analysisDriver,
+          isNot(equals(subProjContextInfo.analysisDriver)));
+      // Check that getDriversInAnalysisRoot() works.
+      List<AnalysisDriver> drivers =
+          manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, isNotNull);
+      expect(drivers, hasLength(2));
+      expect(drivers, contains(projContextInfo.analysisDriver));
+      expect(drivers, contains(subProjContextInfo.analysisDriver));
+    } else {
+      expect(projContextInfo.context != subProjContextInfo.context, isTrue);
+      // Check that contextsInAnalysisRoot() works.
+      List<AnalysisContext> contexts =
+          manager.contextsInAnalysisRoot(projectFolder);
+      expect(contexts, hasLength(2));
+      expect(contexts, contains(projContextInfo.context));
+      expect(contexts, contains(subProjContextInfo.context));
+    }
   }
 
   test_embedder_added() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile([libPath, 'nope.dart']);
     String embedderPath = newFolder([projPath, 'embedder']);
     newFile([embedderPath, 'entry.dart']);
     String embedderSrcPath = newFolder([projPath, 'embedder', 'src']);
     newFile([embedderSrcPath, 'part.dart']);
 
     // Setup _embedder.yaml.
     newFile(
         [libPath, '_embedder.yaml'],
         r'''
 embedded_libs:
   "dart:foobar": "../embedder/entry.dart"
   "dart:typed_data": "../embedder/src/part"
   ''');
 
     Folder projectFolder = resourceProvider.newFolder(projPath);
 
     // NOTE that this is Not in our package path yet.
 
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
-    // Confirm that one context was created.
-    List<AnalysisContext> contexts =
-        manager.contextsInAnalysisRoot(projectFolder);
-    expect(contexts, isNotNull);
-    expect(contexts, hasLength(1));
+    // Confirm that one driver / context was created.
+    if (enableAnalysisDriver) {
+      List<AnalysisDriver> drivers =
+          manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, isNotNull);
+      expect(drivers, hasLength(1));
+    } else {
+      List<AnalysisContext> contexts =
+          manager.contextsInAnalysisRoot(projectFolder);
+      expect(contexts, isNotNull);
+      expect(contexts, hasLength(1));
+    }
 
     // No embedded libs yet.
-    expect(contexts.first.sourceFactory.forUri('dart:typed_data'), isNull);
+    expect(sourceFactory.forUri('dart:typed_data'), isNull);
 
     // Add .packages file that introduces a dependency with embedded libs.
     newFile(
         [projPath, '.packages'],
         r'''
 test_pack:lib/''');
 
     await pumpEventQueue();
 
-    contexts = manager.contextsInAnalysisRoot(projectFolder);
+    // Confirm that we still have just one driver / context.
+    if (enableAnalysisDriver) {
+      List<AnalysisDriver> drivers =
+          manager.getDriversInAnalysisRoot(projectFolder);
+      expect(drivers, isNotNull);
+      expect(drivers, hasLength(1));
+    } else {
+      List<AnalysisContext> contexts =
+          manager.contextsInAnalysisRoot(projectFolder);
 
-    // Confirm that we still have just one context.
-    expect(contexts, isNotNull);
-    expect(contexts, hasLength(1));
+      expect(contexts, isNotNull);
+      expect(contexts, hasLength(1));
+    }
 
     // Embedded lib should be defined now.
-    expect(contexts.first.sourceFactory.forUri('dart:typed_data'), isNotNull);
+    expect(sourceFactory.forUri('dart:typed_data'), isNotNull);
   }
 
   test_embedder_packagespec() 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']);
@@ skipping 33 matching lines @@
 
   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
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(callbacks.currentContextFilePaths[projPath], isEmpty);
+    expect(callbacks.currentFilePaths, isEmpty);
     // "packages" files are ignored during watch
     String filePath2 = path.posix.join(projPath, 'packages', 'file2.dart');
     resourceProvider.newFile(filePath2, 'contents');
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextFilePaths[projPath], isEmpty);
+      expect(callbacks.currentFilePaths, isEmpty);
     });
   }
 
   void test_isInAnalysisRoot_excluded() {
     // prepare paths
     String project = '/project';
     String excludedFolder = '$project/excluded';
     // set roots
     resourceProvider.newFolder(project);
     resourceProvider.newFolder(excludedFolder);
@@ skipping 26 matching lines @@
 
   void test_isInAnalysisRoot_notInRoot() {
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     expect(manager.isInAnalysisRoot('/test.dart'), isFalse);
   }
 
   test_path_filter() async {
     // Setup context.
     Folder root = resourceProvider.newFolder(projPath);
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(callbacks.currentContextFilePaths[projPath], isEmpty);
+    expect(callbacks.currentFilePaths, isEmpty);
     // Set ignore patterns for context.
     ContextInfo rootInfo = manager.getContextInfoFor(root);
     manager.setIgnorePatternsForContext(
         rootInfo, ['sdk_ext/**', 'lib/ignoreme.dart']);
     // Start creating files.
     newFile([projPath, ContextManagerImpl.PUBSPEC_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
     newFile([libPath, 'ignoreme.dart']);
     String sdkExtPath = newFolder([projPath, 'sdk_ext']);
     newFile([sdkExtPath, 'entry.dart']);
     String sdkExtSrcPath = newFolder([projPath, 'sdk_ext', 'src']);
     newFile([sdkExtSrcPath, 'part.dart']);
     // Pump event loop so new files are discovered and added to context.
     await pumpEventQueue();
     // Verify that ignored files were ignored.
-    Map<String, int> fileTimestamps =
-        callbacks.currentContextFilePaths[projPath];
-    expect(fileTimestamps, isNotEmpty);
-    List<String> files = fileTimestamps.keys.toList();
-    expect(files.length, equals(1));
-    expect(files[0], equals('/my/proj/lib/main.dart'));
+    Iterable<String> filePaths = callbacks.currentFilePaths;
+    expect(filePaths, hasLength(1));
+    expect(filePaths, contains('/my/proj/lib/main.dart'));
   }
 
   test_refresh_folder_with_packagespec() {
     // create a context with a .packages file
     String packagespecFile = path.posix.join(projPath, '.packages');
     resourceProvider.newFile(packagespecFile, '');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextPaths.toList(), [projPath]);
+      expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
       callbacks.now++;
       manager.refresh(null);
       return pumpEventQueue().then((_) {
-        expect(callbacks.currentContextPaths.toList(), [projPath]);
+        expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
         expect(callbacks.currentContextTimestamps[projPath], callbacks.now);
       });
     });
   }
 
   // TODO(paulberry): This test only tests PackagesFileDisposition.
   // Once http://dartbug.com/23909 is fixed, add a test for sdk extensions
   // and PackageMapDisposition.
   test_refresh_folder_with_packagespec_subfolders() {
     // Create a folder with no .packages file, containing two subfolders with
     // .packages files.
     String subdir1Path = path.posix.join(projPath, 'subdir1');
     String subdir2Path = path.posix.join(projPath, 'subdir2');
     String packagespec1Path = path.posix.join(subdir1Path, '.packages');
     String packagespec2Path = path.posix.join(subdir2Path, '.packages');
     resourceProvider.newFile(packagespec1Path, '');
     resourceProvider.newFile(packagespec2Path, '');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextPaths.toSet(),
-          [subdir1Path, subdir2Path, projPath].toSet());
+      expect(callbacks.currentContextRoots,
+          unorderedEquals([subdir1Path, subdir2Path, projPath]));
       callbacks.now++;
       manager.refresh(null);
       return pumpEventQueue().then((_) {
-        expect(callbacks.currentContextPaths.toSet(),
-            [subdir1Path, subdir2Path, projPath].toSet());
+        expect(callbacks.currentContextRoots,
+            unorderedEquals([subdir1Path, subdir2Path, projPath]));
         expect(callbacks.currentContextTimestamps[projPath], callbacks.now);
         expect(callbacks.currentContextTimestamps[subdir1Path], callbacks.now);
         expect(callbacks.currentContextTimestamps[subdir2Path], callbacks.now);
       });
     });
   }
 
   test_refresh_folder_with_pubspec() {
     // create a context with a pubspec.yaml file
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextPaths.toList(), [projPath]);
+      expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
       callbacks.now++;
       manager.refresh(null);
       return pumpEventQueue().then((_) {
-        expect(callbacks.currentContextPaths.toList(), [projPath]);
+        expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
         expect(callbacks.currentContextTimestamps[projPath], callbacks.now);
       });
     });
   }
 
   test_refresh_folder_with_pubspec_subfolders() {
     // Create a folder with no pubspec.yaml, containing two subfolders with
     // pubspec.yaml files.
     String subdir1Path = path.posix.join(projPath, 'subdir1');
     String subdir2Path = path.posix.join(projPath, 'subdir2');
     String pubspec1Path = path.posix.join(subdir1Path, 'pubspec.yaml');
     String pubspec2Path = path.posix.join(subdir2Path, 'pubspec.yaml');
     resourceProvider.newFile(pubspec1Path, 'pubspec');
     resourceProvider.newFile(pubspec2Path, 'pubspec');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextPaths.toSet(),
-          [subdir1Path, subdir2Path, projPath].toSet());
+      expect(callbacks.currentContextRoots,
+          unorderedEquals([subdir1Path, subdir2Path, projPath]));
       callbacks.now++;
       manager.refresh(null);
       return pumpEventQueue().then((_) {
-        expect(callbacks.currentContextPaths.toSet(),
-            [subdir1Path, subdir2Path, projPath].toSet());
+        expect(callbacks.currentContextRoots,
+            unorderedEquals([subdir1Path, subdir2Path, projPath]));
         expect(callbacks.currentContextTimestamps[projPath], callbacks.now);
         expect(callbacks.currentContextTimestamps[subdir1Path], callbacks.now);
         expect(callbacks.currentContextTimestamps[subdir2Path], callbacks.now);
       });
     });
   }
 
   test_refresh_oneContext() {
     // create two contexts with pubspec.yaml files
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec1');
 
     String proj2Path = '/my/proj2';
     resourceProvider.newFolder(proj2Path);
     String pubspec2Path = path.posix.join(proj2Path, 'pubspec.yaml');
     resourceProvider.newFile(pubspec2Path, 'pubspec2');
 
     List<String> roots = <String>[projPath, proj2Path];
     manager.setRoots(roots, <String>[], <String, String>{});
     return pumpEventQueue().then((_) {
-      expect(callbacks.currentContextPaths.toList(), unorderedEquals(roots));
+      expect(callbacks.currentContextRoots, unorderedEquals(roots));
       int then = callbacks.now;
       callbacks.now++;
       manager.refresh([resourceProvider.getResource(proj2Path)]);
       return pumpEventQueue().then((_) {
-        expect(callbacks.currentContextPaths.toList(), unorderedEquals(roots));
+        expect(callbacks.currentContextRoots, unorderedEquals(roots));
         expect(callbacks.currentContextTimestamps[projPath], then);
         expect(callbacks.currentContextTimestamps[proj2Path], callbacks.now);
       });
     });
   }
 
   test_sdk_ext_packagespec() async {
     // Create files.
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     newFile([libPath, 'main.dart']);
@@ skipping 24 matching lines @@
     expect(contexts.length, equals(1));
     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];
+    Iterable<String> filePaths = callbacks.currentFilePaths;
     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);
+    if (enableAnalysisDriver) {
+      List<AnalysisDriver> drivers = manager
+          .getDriversInAnalysisRoot(resourceProvider.newFolder(projPath));
+      expect(drivers, hasLength(1));
+      expect(drivers[0], isNotNull);
+    } else {
+      List<AnalysisContext> contextsInAnalysisRoot =
+          manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+      expect(contextsInAnalysisRoot, hasLength(1));
+      expect(contextsInAnalysisRoot[0], isNotNull);
+    }
     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];
+    Iterable<String> filePaths = callbacks.currentFilePaths;
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
   }
 
   void test_setRoots_addFolderWithDummyLink() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newDummyLink(filePath);
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
-    var filePaths = callbacks.currentContextFilePaths[projPath];
-    expect(filePaths, isEmpty);
+    expect(callbacks.currentFilePaths, isEmpty);
   }
 
   void test_setRoots_addFolderWithNestedPackageSpec() {
     String examplePath = newFolder([projPath, ContextManagerTest.EXAMPLE_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
 
     newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME]);
     newFile([libPath, 'main.dart']);
     newFile([examplePath, ContextManagerImpl.PACKAGE_SPEC_NAME]);
     newFile([examplePath, 'example.dart']);
 
     packageMapProvider.packageMap['proj'] = <Folder>[
       resourceProvider.getResource(libPath)
     ];
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
-    expect(callbacks.currentContextPaths, hasLength(2));
+    expect(callbacks.currentContextRoots, hasLength(2));
 
-    expect(callbacks.currentContextPaths, contains(projPath));
-    Set<Source> projSources = callbacks.currentContextSources[projPath];
+    expect(callbacks.currentContextRoots, contains(projPath));
+    Iterable<Source> projSources = callbacks.currentFileSources(projPath);
     expect(projSources, hasLength(1));
     expect(projSources.first.uri.toString(), 'file:///my/proj/lib/main.dart');
 
-    expect(callbacks.currentContextPaths, contains(examplePath));
-    Set<Source> exampleSources = callbacks.currentContextSources[examplePath];
+    expect(callbacks.currentContextRoots, contains(examplePath));
+    Iterable<Source> exampleSources = callbacks.currentFileSources(examplePath);
     expect(exampleSources, hasLength(1));
     expect(exampleSources.first.uri.toString(),
         'file:///my/proj/example/example.dart');
   }
 
   void test_setRoots_addFolderWithNestedPubspec() {
     String examplePath = newFolder([projPath, ContextManagerTest.EXAMPLE_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
 
     newFile([projPath, ContextManagerImpl.PUBSPEC_NAME]);
     newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'proj:lib/');
     newFile([libPath, 'main.dart']);
     newFile([examplePath, ContextManagerImpl.PUBSPEC_NAME]);
     newFile([examplePath, 'example.dart']);
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
-    expect(callbacks.currentContextPaths, hasLength(2));
+    expect(callbacks.currentContextRoots, hasLength(2));
 
-    expect(callbacks.currentContextPaths, contains(projPath));
-    Set<Source> projSources = callbacks.currentContextSources[projPath];
+    expect(callbacks.currentContextRoots, contains(projPath));
+    Iterable<Source> projSources = callbacks.currentFileSources(projPath);
     expect(projSources, hasLength(1));
     expect(projSources.first.uri.toString(), 'package:proj/main.dart');
 
-    expect(callbacks.currentContextPaths, contains(examplePath));
-    Set<Source> exampleSources = callbacks.currentContextSources[examplePath];
+    expect(callbacks.currentContextRoots, contains(examplePath));
+    Iterable<Source> exampleSources = callbacks.currentFileSources(examplePath);
     expect(exampleSources, hasLength(1));
     expect(exampleSources.first.uri.toString(),
         'file:///my/proj/example/example.dart');
   }
 
   void test_setRoots_addFolderWithoutPubspec() {
     packageMapProvider.packageMap = null;
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
+    expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_addFolderWithPackagespec() {
     String packagespecPath = path.posix.join(projPath, '.packages');
     resourceProvider.newFile(packagespecPath,
         'unittest:file:///home/somebody/.pub/cache/unittest-0.9.9/lib/');
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     File mainFile =
         resourceProvider.newFile(path.posix.join(libPath, 'main.dart'), '');
     Source source = mainFile.createSource();
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     // verify
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextFilePaths[projPath], hasLength(1));
+    expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
+    expect(callbacks.currentFilePaths, hasLength(1));
 
     // smoketest resolution
-    SourceFactory sourceFactory = callbacks.currentContext.sourceFactory;
     Source resolvedSource =
         sourceFactory.resolveUri(source, 'package:unittest/unittest.dart');
     expect(resolvedSource, isNotNull);
     expect(resolvedSource.fullName,
         equals('/home/somebody/.pub/cache/unittest-0.9.9/lib/unittest.dart'));
   }
 
   void test_setRoots_addFolderWithPackagespecAndPackageRoot() {
     // The package root should take priority.
     String packagespecPath = path.posix.join(projPath, '.packages');
     resourceProvider.newFile(packagespecPath,
         'unittest:file:///home/somebody/.pub/cache/unittest-0.9.9/lib/');
     String packageRootPath = '/package/root/';
     manager.setRoots(<String>[projPath], <String>[],
         <String, String>{projPath: packageRootPath});
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
+    expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
     _checkPackageRoot(projPath, packageRootPath);
   }
 
   void test_setRoots_addFolderWithPubspec() {
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
+    expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_addFolderWithPubspec_andPackagespec() {
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     String packagespecPath = path.posix.join(projPath, '.packages');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     resourceProvider.newFile(packagespecPath, '');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     callbacks.assertContextPaths([projPath]);
   }
 
   void test_setRoots_addFolderWithPubspecAndLib() {
     String binPath = newFolder([projPath, ContextManagerTest.BIN_NAME]);
     String libPath = newFolder([projPath, ContextManagerTest.LIB_NAME]);
     String srcPath = newFolder([libPath, ContextManagerTest.SRC_NAME]);
     String testPath = newFolder([projPath, ContextManagerTest.TEST_NAME]);
 
     newFile([projPath, ContextManagerImpl.PUBSPEC_NAME]);
     newFile([projPath, ContextManagerImpl.PACKAGE_SPEC_NAME], 'proj:lib/');
     String appPath = newFile([binPath, 'app.dart']);
     newFile([libPath, 'main.dart']);
     newFile([srcPath, 'internal.dart']);
     String testFilePath = newFile([testPath, 'main_test.dart']);
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    Set<Source> sources = callbacks.currentContextSources[projPath];
+    Iterable<Source> sources = callbacks.currentFileSources(projPath);
 
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
+    expect(callbacks.currentContextRoots, unorderedEquals([projPath]));
     expect(sources, hasLength(4));
     List<String> uris =
         sources.map((Source source) => source.uri.toString()).toList();
     expect(uris, contains('file://$appPath'));
     expect(uris, contains('package:proj/main.dart'));
     expect(uris, contains('package:proj/src/internal.dart'));
     expect(uris, contains('file://$testFilePath'));
   }
 
   void test_setRoots_addFolderWithPubspecAndPackagespecFolders() {
@@ skipping 249 matching lines @@
         ContextInfo projectInfo = rootInfo.children[0];
         expect(projectInfo.folder.path, project);
         expect(projectInfo.children, hasLength(1));
         {
           ContextInfo exampleInfo = projectInfo.children[0];
           expect(exampleInfo.folder.path, example);
           expect(exampleInfo.children, isEmpty);
         }
       }
     }
-    expect(callbacks.currentContextPaths, hasLength(2));
-    expect(callbacks.currentContextPaths, unorderedEquals([project, example]));
+    expect(callbacks.currentContextRoots, unorderedEquals([project, example]));
   }
 
   void test_setRoots_nested_includedByOuter_outerPubspec() {
     String project = '/project';
     String projectPubspec = '$project/pubspec.yaml';
     String example = '$project/example';
     // create files
     resourceProvider.newFile(projectPubspec, 'name: project');
     resourceProvider.newFolder(example);
     manager
         .setRoots(<String>[project, example], <String>[], <String, String>{});
     // verify
     {
       ContextInfo rootInfo = manager.rootInfo;
       expect(rootInfo.children, hasLength(1));
       {
         ContextInfo projectInfo = rootInfo.children[0];
         expect(projectInfo.folder.path, project);
         expect(projectInfo.children, isEmpty);
       }
     }
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, unorderedEquals([project]));
+    expect(callbacks.currentContextRoots, unorderedEquals([project]));
   }
 
   void test_setRoots_nested_includedByOuter_twoPubspecs() {
     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');
     manager
         .setRoots(<String>[project, example], <String>[], <String, String>{});
     // verify
     {
       ContextInfo rootInfo = manager.rootInfo;
       expect(rootInfo.children, hasLength(1));
       {
         ContextInfo projectInfo = rootInfo.children[0];
         expect(projectInfo.folder.path, project);
         expect(projectInfo.children, hasLength(1));
         {
           ContextInfo exampleInfo = projectInfo.children[0];
           expect(exampleInfo.folder.path, example);
           expect(exampleInfo.children, isEmpty);
         }
       }
     }
-    expect(callbacks.currentContextPaths, hasLength(2));
-    expect(callbacks.currentContextPaths, unorderedEquals([project, example]));
+    expect(callbacks.currentContextRoots, unorderedEquals([project, example]));
   }
 
   void test_setRoots_newFolderWithPackageRoot() {
     String packageRootPath = '/package';
     manager.setRoots(<String>[projPath], <String>[],
         <String, String>{projPath: packageRootPath});
     _checkPackageRoot(projPath, equals(packageRootPath));
   }
 
   void test_setRoots_newlyAddedFoldersGetProperPackageMap() {
@@ skipping 20 matching lines @@
     manager.setRoots(
         <String>[project], <String>[excludedFolder], <String, String>{});
     callbacks.assertContextPaths([project]);
   }
 
   void test_setRoots_noContext_inDotFolder() {
     String pubspecPath = path.posix.join(projPath, '.pub', 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'name: test');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
+    expect(callbacks.currentContextRoots, hasLength(1));
+    expect(callbacks.currentContextRoots, contains(projPath));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_noContext_inPackagesFolder() {
     String pubspecPath = path.posix.join(projPath, 'packages', 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'name: test');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
-    expect(callbacks.currentContextPaths, hasLength(1));
-    expect(callbacks.currentContextPaths, contains(projPath));
-    expect(callbacks.currentContextFilePaths[projPath], hasLength(0));
+    expect(callbacks.currentContextRoots, hasLength(1));
+    expect(callbacks.currentContextRoots, contains(projPath));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_packageResolver() {
     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);
+    if (enableAnalysisDriver) {
+      var drivers = manager
+          .getDriversInAnalysisRoot(resourceProvider.newFolder(projPath));
+      expect(drivers, hasLength(1));
+      expect(drivers[0], isNotNull);
+    } else {
+      List<AnalysisContext> contextsInAnalysisRoot =
+          manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+      expect(contextsInAnalysisRoot, hasLength(1));
+      expect(contextsInAnalysisRoot[0], isNotNull);
+    }
     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, '');
     resourceProvider.newFile(fileB, '');
     manager.setRoots(<String>[project], <String>[], <String, String>{});
     callbacks.assertContextPaths([project]);
     callbacks.assertContextFiles(project, [fileA]);
   }
 
   void test_setRoots_removeFolderWithoutPubspec() {
     packageMapProvider.packageMap = null;
     // add one root - there is a context
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(callbacks.currentContextPaths, hasLength(1));
+    expect(callbacks.currentContextRoots, hasLength(1));
     // set empty roots - no contexts
     manager.setRoots(<String>[], <String>[], <String, String>{});
-    expect(callbacks.currentContextPaths, hasLength(0));
-    expect(callbacks.currentContextFilePaths, hasLength(0));
+    expect(callbacks.currentContextRoots, hasLength(0));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_removeFolderWithPackagespec() {
     // create a pubspec
     String pubspecPath = path.posix.join(projPath, '.packages');
     resourceProvider.newFile(pubspecPath, '');
     // add one root - there is a context
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     expect(manager.changeSubscriptions, hasLength(1));
-    expect(callbacks.currentContextPaths, hasLength(1));
+    expect(callbacks.currentContextRoots, hasLength(1));
     // set empty roots - no contexts
     manager.setRoots(<String>[], <String>[], <String, String>{});
     expect(manager.changeSubscriptions, hasLength(0));
-    expect(callbacks.currentContextPaths, hasLength(0));
-    expect(callbacks.currentContextFilePaths, hasLength(0));
+    expect(callbacks.currentContextRoots, hasLength(0));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_removeFolderWithPackagespecFolder() {
     // prepare paths
     String projectA = '/projectA';
     String projectB = '/projectB';
     String subProjectA = '$projectA/sub';
     String subProjectB = '$projectB/sub';
     String projectA_file = '$projectA/a.dart';
     String projectB_file = '$projectB/a.dart';
@@ skipping 23 matching lines @@
     callbacks.assertContextFiles(projectA, [projectA_file]);
     callbacks.assertContextFiles(subProjectA, [subProjectA_file]);
   }
 
   void test_setRoots_removeFolderWithPubspec() {
     // create a pubspec
     String pubspecPath = path.posix.join(projPath, 'pubspec.yaml');
     resourceProvider.newFile(pubspecPath, 'pubspec');
     // add one root - there is a context
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
-    expect(callbacks.currentContextPaths, hasLength(1));
+    expect(callbacks.currentContextRoots, hasLength(1));
     // set empty roots - no contexts
     manager.setRoots(<String>[], <String>[], <String, String>{});
-    expect(callbacks.currentContextPaths, hasLength(0));
-    expect(callbacks.currentContextFilePaths, hasLength(0));
+    expect(callbacks.currentContextRoots, hasLength(0));
+    expect(callbacks.currentFilePaths, hasLength(0));
   }
 
   void test_setRoots_removeFolderWithPubspecFolder() {
     // prepare paths
     String projectA = '/projectA';
     String projectB = '/projectB';
     String subProjectA = '$projectA/sub';
     String subProjectB = '$projectB/sub';
     String projectA_file = '$projectA/a.dart';
     String projectB_file = '$projectB/a.dart';
@@ skipping 51 matching lines @@
     String fileA = '$project/foo.dart';
     resourceProvider.newFile(fileA, '');
     manager.setRoots(<String>[project], <String>[], <String, String>{});
     callbacks.assertContextPaths([project]);
     callbacks.assertContextFiles(project, [fileA]);
   }
 
   test_watch_addDummyLink() {
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // empty folder initially
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
-    expect(filePaths, isEmpty);
+    expect(callbacks.currentFilePaths, isEmpty);
     // add link
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newDummyLink(filePath);
     // the link was ignored
     return pumpEventQueue().then((_) {
-      expect(filePaths, isEmpty);
+      expect(callbacks.currentFilePaths, isEmpty);
     });
   }
 
   test_watch_addFile() {
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // empty folder initially
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
-    expect(filePaths, hasLength(0));
+    expect(callbacks.currentFilePaths, hasLength(0));
     // add file
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newFile(filePath, 'contents');
     // the file was added
     return pumpEventQueue().then((_) {
+      Iterable<String> filePaths = callbacks.currentFilePaths;
       expect(filePaths, hasLength(1));
       expect(filePaths, contains(filePath));
     });
   }
 
   test_watch_addFile_excluded() {
     // prepare paths
     String project = '/project';
     String folderA = '$project/aaa';
     String folderB = '$project/bbb';
@@ skipping 79 matching lines @@
     callbacks.assertContextFiles(project, [fileA]);
     resourceProvider.newFile(fileB, '');
     await pumpEventQueue();
     callbacks.assertContextPaths([project]);
     callbacks.assertContextFiles(project, [fileA, fileB]);
   }
 
   test_watch_addFileInSubfolder() {
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // empty folder initially
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
-    expect(filePaths, hasLength(0));
+    expect(callbacks.currentFilePaths, hasLength(0));
     // add file in subfolder
     String filePath = path.posix.join(projPath, 'foo', 'bar.dart');
     resourceProvider.newFile(filePath, 'contents');
     // the file was added
     return pumpEventQueue().then((_) {
+      Iterable<String> filePaths = callbacks.currentFilePaths;
       expect(filePaths, hasLength(1));
       expect(filePaths, contains(filePath));
     });
   }
 
   test_watch_addPackagespec_toRoot() {
     // prepare paths
     String root = '/root';
     String rootFile = '$root/root.dart';
     String rootPackagespec = '$root/.packages';
@@ skipping 163 matching lines @@
     });
   }
 
   test_watch_deleteFile() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     // add root with a file
     File file = resourceProvider.newFile(filePath, 'contents');
     Folder projFolder = file.parent;
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // the file was added
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
+    Iterable<String> filePaths = callbacks.currentFilePaths;
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
     expect(file.exists, isTrue);
     expect(projFolder.exists, isTrue);
     // delete the file
     resourceProvider.deleteFile(filePath);
     return pumpEventQueue().then((_) {
       expect(file.exists, isFalse);
       expect(projFolder.exists, isTrue);
-      return expect(filePaths, hasLength(0));
+      return expect(callbacks.currentFilePaths, hasLength(0));
     });
   }
 
   test_watch_deleteFolder() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     // add root with a file
     File file = resourceProvider.newFile(filePath, 'contents');
     Folder projFolder = file.parent;
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // the file was added
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
+    Iterable<String> filePaths = callbacks.currentFilePaths;
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
     expect(file.exists, isTrue);
     expect(projFolder.exists, isTrue);
     // delete the folder
     resourceProvider.deleteFolder(projPath);
     return pumpEventQueue().then((_) {
       expect(file.exists, isFalse);
       expect(projFolder.exists, isFalse);
-      return expect(filePaths, hasLength(0));
+      return expect(callbacks.currentFilePaths, hasLength(0));
     });
   }
 
   test_watch_deletePackagespec_fromRoot() {
     // prepare paths
     String root = '/root';
     String rootPubspec = '$root/.packages';
     String rootFile = '$root/root.dart';
     // create files
     resourceProvider.newFile(rootPubspec, '');
@@ skipping 117 matching lines @@
       callbacks.assertContextFiles(root, [rootFile, subFile]);
     });
   }
 
   test_watch_modifyFile() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     // add root with a file
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // the file was added
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
-    expect(filePaths, hasLength(1));
-    expect(filePaths, contains(filePath));
-    expect(filePaths[filePath], equals(callbacks.now));
+    if (enableAnalysisDriver) {
+      Iterable<String> filePaths = callbacks.currentFilePaths;
+      expect(filePaths, hasLength(1));
+      expect(filePaths, contains(filePath));
+      // TODO(brianwilkerson) Test when the file was modified
+    } else {
+      Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
+      expect(filePaths, hasLength(1));
+      expect(filePaths, contains(filePath));
+      expect(filePaths[filePath], equals(callbacks.now));
+    }
     // update the file
     callbacks.now++;
     resourceProvider.modifyFile(filePath, 'new contents');
     return pumpEventQueue().then((_) {
+      if (enableAnalysisDriver) {
+        // TODO(brianwilkerson) Test when the file was modified
+        return null;
+      }
+      Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
       return expect(filePaths[filePath], equals(callbacks.now));
     });
   }
 
   test_watch_modifyPackageMapDependency_fail() async {
     // create a dependency file
     String dependencyPath = path.posix.join(projPath, 'dep');
     resourceProvider.newFile(dependencyPath, 'contents');
     packageMapProvider.dependencies.add(dependencyPath);
     // create a Dart file
@@ skipping 13 matching lines @@
 
   test_watch_modifyPackagespec() {
     String packagesPath = '$projPath/.packages';
     String filePath = '$projPath/bin/main.dart';
 
     resourceProvider.newFile(packagesPath, '');
     resourceProvider.newFile(filePath, 'library main;');
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
-    Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
+    Iterable<String> filePaths = callbacks.currentFilePaths;
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
     expect(_currentPackageMap, isEmpty);
 
     // update .packages
     callbacks.now++;
     resourceProvider.modifyFile(packagesPath, 'main:./lib/');
     return pumpEventQueue().then((_) {
       // verify new package info
       expect(_currentPackageMap.keys, unorderedEquals(['main']));
     });
   }
 
   /**
    * 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 AbstractContextManagerTest_Driver extends AbstractContextManagerTest {
+  bool get enableAnalysisDriver => true;
+
+  @failingTest
+  test_embedder_added() {
+    // NoSuchMethodError: The getter 'apiSignature' was called on null.
+    // Receiver: null
+    // Tried calling: apiSignature
+    // dart:core                                                          Object.noSuchMethod
+    // package:analyzer/src/dart/analysis/driver.dart 460:20              AnalysisDriver.configure
+    // package:analysis_server/src/context_manager.dart 1043:16           ContextManagerImpl._checkForPackagespecUpdate
+    // package:analysis_server/src/context_manager.dart 1553:5            ContextManagerImpl._handleWatchEvent
+    //return super.test_embedder_added();
+    fail('NoSuchMethodError');
+  }
+
+  @failingTest
+  test_embedder_packagespec() async {
+    // NoSuchMethodError: The getter 'apiSignature' was called on null.
+    // Receiver: null
+    // Tried calling: apiSignature
+    // dart:core                                                          Object.noSuchMethod
+    // package:analyzer/src/dart/analysis/driver.dart 248:20              AnalysisDriver.AnalysisDriver
+    // test/context_manager_test.dart 2698:25                             TestContextManagerCallbacks.addAnalysisDriver
+    // package:analysis_server/src/context_manager.dart 1186:39           ContextManagerImpl._createContext
+    // package:analysis_server/src/context_manager.dart 1247:16           ContextManagerImpl._createContexts
+    // package:analysis_server/src/context_manager.dart 886:9             ContextManagerImpl.setRoots
+    // test/context_manager_test.dart 154:13                              AbstractContextManagerTest.test_embedder_packagespec.<async>
+    return super.test_embedder_packagespec();
+  }
+
+  @failingTest
+  void test_setRoots_addPackageRoot() {
+    // Bad state: Should not be used with the new analysis driver
+    // package:analysis_server/src/context_manager.dart 561:7             ContextManagerImpl.folderMap
+    // package:analysis_server/src/context_manager.dart 1709:31           ContextManagerImpl._updateContextPackageUriResolver
+    // package:analysis_server/src/context_manager.dart 1668:5            ContextManagerImpl._recomputeFolderDisposition
+    // package:analysis_server/src/context_manager.dart 1420:7            ContextManagerImpl._handleWatchEvent
+    return super.test_setRoots_addPackageRoot();
+  }
+
+  @failingTest
+  void test_setRoots_changePackageRoot() {
+    // Bad state: Should not be used with the new analysis driver
+    // package:analysis_server/src/context_manager.dart 561:7             ContextManagerImpl.folderMap
+    // package:analysis_server/src/context_manager.dart 1709:31           ContextManagerImpl._updateContextPackageUriResolver
+    // package:analysis_server/src/context_manager.dart 1668:5            ContextManagerImpl._recomputeFolderDisposition
+    // package:analysis_server/src/context_manager.dart 1420:7            ContextManagerImpl._handleWatchEvent
+    return super.test_setRoots_changePackageRoot();
+  }
+
+  @failingTest
+  void test_setRoots_removePackageRoot() {
+    // Bad state: Should not be used with the new analysis driver
+    // package:analysis_server/src/context_manager.dart 561:7             ContextManagerImpl.folderMap
+    // package:analysis_server/src/context_manager.dart 1709:31           ContextManagerImpl._updateContextPackageUriResolver
+    // package:analysis_server/src/context_manager.dart 1668:5            ContextManagerImpl._recomputeFolderDisposition
+    // package:analysis_server/src/context_manager.dart 1420:7            ContextManagerImpl._handleWatchEvent
+    return super.test_setRoots_removePackageRoot();
+  }
+
+  @failingTest
+  test_watch_modifyPackageMapDependency_fail() async {
+    // Bad state: Should not be used with the new analysis driver
+    // package:analysis_server/src/context_manager.dart 561:7             ContextManagerImpl.folderMap
+    // package:analysis_server/src/context_manager.dart 1709:31           ContextManagerImpl._updateContextPackageUriResolver
+    // package:analysis_server/src/context_manager.dart 1668:5            ContextManagerImpl._recomputeFolderDisposition
+    // package:analysis_server/src/context_manager.dart 1420:7            ContextManagerImpl._handleWatchEvent
+    //return super.test_watch_modifyPackageMapDependency_fail();
+    fail('StateError thrown');
   }
 }
 
 abstract class ContextManagerTest {
   /**
    * The name of the 'bin' directory.
    */
   static const String BIN_NAME = 'bin';
 
   /**
@@ skipping 152 matching lines @@
     // 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;
+    if (enableAnalysisDriver) {
+      ContextInfo info = manager.getContextInfoFor(folder);
+      return info.analysisDriver.sourceFactory?.packageMap;
+    } else {
+      return manager.folderMap[folder]?.sourceFactory?.packageMap;
+    }
   }
 }
 
 @reflectiveTest
 class ContextManagerWithNewOptionsTest extends ContextManagerWithOptionsTest {
   String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
 }
 
 @reflectiveTest
 class ContextManagerWithNewOptionsTest_Driver
@@ skipping 530 matching lines @@
     - '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.
     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'));
+      expect(drivers[0].name, equals('/my/proj'));
+      expect(drivers[1].name, equals('/my/proj/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 {
@@ skipping 23 matching lines @@
   ''');
     // 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.
     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'));
+      expect(drivers[0].name, equals('/my/proj'));
+      expect(drivers[1].name, equals('/my/proj/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.
@@ skipping 20 matching lines @@
   exclude:
     - 'other_lib/*'
 ''');
     // Setup context / driver.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     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'));
+      expect(drivers[0].name, equals('/my/proj'));
+      expect(drivers[1].name, equals('/my/proj/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'));
     }
   }
 
@@ skipping 22 matching lines @@
         ContextInfo projectInfo = rootInfo.children[0];
         expect(projectInfo.folder.path, project);
         expect(projectInfo.children, hasLength(1));
         {
           ContextInfo exampleInfo = projectInfo.children[0];
           expect(exampleInfo.folder.path, example);
           expect(exampleInfo.children, isEmpty);
         }
       }
     }
-    expect(callbacks.currentContextPaths, hasLength(2));
-    expect(callbacks.currentContextPaths, unorderedEquals([project, example]));
+    expect(callbacks.currentContextRoots, hasLength(2));
+    expect(callbacks.currentContextRoots, unorderedEquals([project, example]));
   }
 
   void test_setRoots_nested_excludedByOuter_deep() {
     String a = '/a';
     String c = '$a/b/c';
     String aPubspec = '$a/pubspec.yaml';
     String cPubspec = '$c/pubspec.yaml';
     // create files
     resourceProvider.newFile(aPubspec, 'name: aaa');
     resourceProvider.newFile(cPubspec, 'name: ccc');
@@ skipping 13 matching lines @@
         ContextInfo aInfo = rootInfo.children[0];
         expect(aInfo.folder.path, a);
         expect(aInfo.children, hasLength(1));
         {
           ContextInfo cInfo = aInfo.children[0];
           expect(cInfo.folder.path, c);
           expect(cInfo.children, isEmpty);
         }
       }
     }
-    expect(callbacks.currentContextPaths, hasLength(2));
-    expect(callbacks.currentContextPaths, unorderedEquals([a, c]));
+    expect(callbacks.currentContextRoots, hasLength(2));
+    expect(callbacks.currentContextRoots, unorderedEquals([a, c]));
   }
 
   test_strong_mode_analysis_option() async {
     // Create files.
     newFile(
         [projPath, optionsFileName],
         r'''
 analyzer:
   strong-mode: true
 ''');
@@ skipping 16 matching lines @@
    * The analysis context that was created.
    */
   AnalysisContext currentContext;
 
   /**
    * The analysis driver that was created.
    */
   AnalysisDriver currentDriver;
 
   /**
+   * A table mapping paths to the analysis driver associated with that path.
+   */
+  Map<String, AnalysisDriver> driverMap = <String, AnalysisDriver>{};
+
+  /**
    * 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>>{};
 
@@ skipping 33 matching lines @@
       this.resourceProvider, this.sdkManager, 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.
+   * Return the paths to the context roots that currently exist.
    */
-  Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
+  Iterable<String> get currentContextRoots {
+    return currentContextTimestamps.keys;
+  }
+
+  /**
+   * Return the paths to the files being analyzed in the current context root.
+   */
+  Iterable<String> get currentFilePaths {
+    if (currentDriver == null) {
+      if (currentContext == null) {
+        return <String>[];
+      }
+      Map<String, int> fileMap = currentContextFilePaths[currentContext.name];
+      if (fileMap == null) {
+        return <String>[];
+      }
+      return fileMap.keys;
+    }
+    return currentDriver.addedFiles;
+  }
 
   /**
    * Return the current source factory.
    */
   SourceFactory get sourceFactory => currentDriver == null
       ? currentContext.sourceFactory
       : currentDriver.sourceFactory;
 
   @override
   AnalysisDriver addAnalysisDriver(Folder folder, AnalysisOptions options) {
     String path = folder.path;
-    expect(currentContextPaths, isNot(contains(path)));
+    expect(currentContextRoots, 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.name = path;
+    driverMap[path] = currentDriver;
     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)));
+    expect(currentContextRoots, 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);
+    currentContext = builder.buildContext(path);
+    currentContext.name = path;
     return currentContext;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
-    if (currentDriver != null) {
+    AnalysisDriver driver = driverMap[contextFolder.path];
+    if (driver != null) {
       changeSet.addedSources.forEach((source) {
-        currentDriver.addFile(source.fullName);
+        driver.addFile(source.fullName);
       });
       changeSet.changedSources.forEach((source) {
-        currentDriver.changeFile(source.fullName);
+        driver.changeFile(source.fullName);
       });
       changeSet.removedSources.forEach((source) {
-        currentDriver.removeFile(source.fullName);
+        driver.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);
       }
@@ skipping 10 matching lines @@
       currentContext.applyChanges(changeSet);
     }
   }
 
   @override
   void applyFileRemoved(AnalysisDriver driver, String file) {
     driver.removeFile(file);
   }
 
   void assertContextFiles(String contextPath, List<String> expectedFiles) {
-    var actualFiles = currentContextFilePaths[contextPath].keys;
-    expect(actualFiles, unorderedEquals(expectedFiles));
+    expect(getCurrentFilePaths(contextPath), unorderedEquals(expectedFiles));
   }
 
   void assertContextPaths(List<String> expected) {
-    expect(currentContextPaths, unorderedEquals(expected));
+    expect(currentContextRoots, unorderedEquals(expected));
   }
 
   @override
   void computingPackageMap(bool computing) {
     // Do nothing.
   }
 
   @override
   ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options,
       {bool useSummaries = false}) {
     ContextBuilderOptions builderOptions = new ContextBuilderOptions();
     builderOptions.defaultOptions = options;
     ContextBuilder builder = new ContextBuilder(
         resourceProvider, sdkManager, new ContentCache(),
         options: builderOptions);
     return builder;
   }
 
+  /**
+   * Return the paths to the files being analyzed in the current context root.
+   */
+  Iterable<Source> currentFileSources(String contextPath) {
+    if (currentDriver == null) {
+      if (currentContext == null) {
+        return <Source>[];
+      }
+      Set<Source> sources = currentContextSources[contextPath];
+      return sources ?? <Source>[];
+    }
+    AnalysisDriver driver = driverMap[contextPath];
+    SourceFactory sourceFactory = driver.sourceFactory;
+    return driver.addedFiles.map((String path) {
+      File file = resourceProvider.getFile(path);
+      Source source = file.createSource();
+      Uri uri = sourceFactory.restoreUri(source);
+      return file.createSource(uri);
+    });
+  }
+
+  /**
+   * Return the paths to the files being analyzed in the current context root.
+   */
+  Iterable<String> getCurrentFilePaths(String contextPath) {
+    if (currentDriver == null) {
+      if (currentContext == null) {
+        return <String>[];
+      }
+      Map<String, int> fileMap = currentContextFilePaths[contextPath];
+      if (fileMap == null) {
+        return <String>[];
+      }
+      return fileMap.keys;
+    }
+    return driverMap[contextPath].addedFiles;
+  }
+
   @override
   void moveContext(Folder from, Folder to) {
     String path = from.path;
     String path2 = to.path;
     expect(currentContextFilePaths, contains(path));
     expect(currentContextTimestamps, contains(path));
     expect(currentContextSources, contains(path));
     expect(currentContextFilePaths, isNot(contains(path2)));
     expect(currentContextTimestamps, isNot(contains(path2)));
     expect(currentContextSources, isNot(contains(path2)));
     currentContextFilePaths[path2] = currentContextFilePaths.remove(path);
     currentContextTimestamps[path2] = currentContextTimestamps.remove(path);
     currentContextSources[path2] = currentContextSources.remove(path);
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     String path = folder.path;
-    expect(currentContextPaths, contains(path));
+    expect(currentContextRoots, contains(path));
     currentContextTimestamps.remove(path);
     currentContextFilePaths.remove(path);
     currentContextSources.remove(path);
     lastFlushedFiles = flushedFiles;
   }
 
   @override
   void updateContextPackageUriResolver(AnalysisContext context) {
     // Nothing to do.
   }
@@ skipping 12 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }