Remove ability to disable new 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:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
@@ skipping 32 matching lines @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AbstractContextManagerTest);
     defineReflectiveTests(ContextManagerWithNewOptionsTest);
     defineReflectiveTests(ContextManagerWithOldOptionsTest);
   });
 }
 
 @reflectiveTest
 class AbstractContextManagerTest extends ContextManagerTest {
-  bool get enableAnalysisDriver => true;
-
   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 projectFolder = resourceProvider.getFolder(projPath);
     ContextInfo projContextInfo = manager.getContextInfoFor(projectFolder);
     expect(projContextInfo, isNotNull);
     expect(projContextInfo.folder, projectFolder);
     ContextInfo subProjContextInfo = manager.getContextInfoFor(subProjFolder);
     expect(subProjContextInfo, isNotNull);
     expect(subProjContextInfo.folder, subProjFolder);
-    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));
-    }
+    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));
   }
 
   @failingTest
   test_embedder_added() 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 460:20              AnalysisDriver.configure
     // package:analysis_server/src/context_manager.dart 1043:16           ContextManagerImpl._checkForPackagespecUpdate
@@ skipping 19 matching lines @@
   ''');
 
     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 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));
-    }
+    List<AnalysisDriver> drivers =
+        manager.getDriversInAnalysisRoot(projectFolder);
+    expect(drivers, isNotNull);
+    expect(drivers, hasLength(1));
 
     // No embedded libs yet.
     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();
 
     // 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);
-
-      expect(contexts, isNotNull);
-      expect(contexts, hasLength(1));
-    }
+    drivers = manager.getDriversInAnalysisRoot(projectFolder);
+    expect(drivers, isNotNull);
+    expect(drivers, hasLength(1));
 
     // Embedded lib should be defined now.
     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']);
@@ skipping 261 matching lines @@
   }
 
   void test_setRoots_addFolderWithDartFile() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     Iterable<String> filePaths = callbacks.currentFilePaths;
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
-    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);
-    }
+    List<AnalysisDriver> drivers =
+        manager.getDriversInAnalysisRoot(resourceProvider.newFolder(projPath));
+    expect(drivers, hasLength(1));
+    expect(drivers[0], isNotNull);
     Source result = sourceFactory.forUri('dart:async');
     expect(result, isNotNull);
   }
 
   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
     Iterable<String> filePaths = callbacks.currentFilePaths;
@@ skipping 517 matching lines @@
     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>{});
 
-    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);
-    }
+    var drivers =
+        manager.getDriversInAnalysisRoot(resourceProvider.newFolder(projPath));
+    expect(drivers, hasLength(1));
+    expect(drivers[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';
@@ skipping 618 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
-    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));
-    }
+    Iterable<String> filePaths = callbacks.currentFilePaths;
+    expect(filePaths, hasLength(1));
+    expect(filePaths, contains(filePath));
+    // TODO(brianwilkerson) Test when the file was modified
     // 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));
+      // TODO(brianwilkerson) Test when the file was modified
     });
   }
 
   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
     String dartFilePath = path.posix.join(projPath, 'main.dart');
@@ skipping 115 matching lines @@
       '**/${AnalysisEngine.ANALYSIS_OPTIONS_FILE}',
       '**/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}'
     ];
     return patterns
         .map((pattern) => new Glob(path.posix.separator, pattern))
         .toList();
   }
 
   AnalysisOptions get analysisOptions => callbacks.analysisOptions;
 
-  bool get enableAnalysisDriver => false;
-
   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);
@@ skipping 48 matching lines @@
     // Create an SDK in the mock file system.
     new MockSdk(generateSummaryFiles: true, resourceProvider: resourceProvider);
     DartSdkManager sdkManager = new DartSdkManager('/', true);
     manager = new ContextManagerImpl(
         resourceProvider,
         sdkManager,
         providePackageResolver,
         packageMapProvider,
         analysisFilesGlobs,
         InstrumentationService.NULL_SERVICE,
-        new AnalysisOptionsImpl(),
-        enableAnalysisDriver);
+        new AnalysisOptionsImpl());
     PerformanceLog logger = new PerformanceLog(new NullStringSink());
     AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(logger);
     callbacks = new TestContextManagerCallbacks(
         resourceProvider, sdkManager, logger, scheduler);
     manager.callbacks = callbacks;
   }
 
   /**
    * 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);
-    if (enableAnalysisDriver) {
-      ContextInfo info = manager.getContextInfoFor(folder);
-      return info.analysisDriver.sourceFactory?.packageMap;
-    } else {
-      return manager.folderMap[folder]?.sourceFactory?.packageMap;
-    }
+    ContextInfo info = manager.getContextInfoFor(folder);
+    return info.analysisDriver.sourceFactory?.packageMap;
   }
 }
 
 @reflectiveTest
 class ContextManagerWithNewOptionsTest extends ContextManagerWithOptionsTest {
-  bool get enableAnalysisDriver => true;
-
   String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
 }
 
 @reflectiveTest
 class ContextManagerWithOldOptionsTest extends ContextManagerWithOptionsTest {
-  bool get enableAnalysisDriver => true;
-
   String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_FILE;
 }
 
 abstract class ContextManagerWithOptionsTest extends ContextManagerTest {
   String get optionsFileName;
 
   test_analysis_options_file_delete() async {
     // Setup analysis options
     newFile(
         [projPath, optionsFileName],
@@ skipping 384 matching lines @@
     resourceProvider.newFile(
         '$projPath/$optionsFileName',
         r'''
 analyzer:
   strong-mode: false
 ''');
     // Create the context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
-    if (enableAnalysisDriver) {
-      AnalysisResult result =
-          await callbacks.currentDriver.getResult(file.path);
+    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, 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);
-    }
+    // 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);
 
     // 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.
-    if (enableAnalysisDriver) {
-      AnalysisResult result =
-          await callbacks.currentDriver.getResult(file.path);
+    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);
-    }
+    // Not strong mode - both in the context and the SDK context.
+    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);
   }
 
   @failingTest
   test_path_filter_analysis_option() async {
     // This fails because we're not analyzing the analysis options file.
     // 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.
     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']));
-    }
+    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']));
   }
 
   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 12 matching lines @@
         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.
     Folder projectFolder = resourceProvider.newFolder(projPath);
-    if (enableAnalysisDriver) {
-      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
-      expect(drivers, hasLength(2));
-      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'));
-    }
+    var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+    expect(drivers, hasLength(2));
+    expect(drivers[0].name, equals('/my/proj'));
+    expect(drivers[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
@@ skipping 13 matching lines @@
 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.
     Folder projectFolder = resourceProvider.newFolder(projPath);
-    if (enableAnalysisDriver) {
-      var drivers = manager.getDriversInAnalysisRoot(projectFolder);
-      expect(drivers, hasLength(2));
-      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'));
-    }
+    var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+    expect(drivers, hasLength(2));
+    expect(drivers[0].name, equals('/my/proj'));
+    expect(drivers[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
@@ skipping 11 matching lines @@
         [projPath, optionsFileName],
         r'''
 analyzer:
   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('/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'));
-    }
+    var drivers = manager.getDriversInAnalysisRoot(projectFolder);
+    expect(drivers, hasLength(2));
+    expect(drivers[0].name, equals('/my/proj'));
+    expect(drivers[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 394 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }