Use checked-in .package file for building and testing

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 938 matching lines @@
       commands.add(CommandBuilder.instance.getMakeSymlinkCommand(
           expectLink.toNativePath(), expectLinkTarget.toNativePath()));
 
       return {'commands': commands, 'package-root': newPackageRoot,};
     }
 
     // If this test is inside a package, we will check if there is a
     // pubspec.yaml file and if so, create a custom package root for it.
     List<Command> baseCommands = <Command>[];
     Path packageRoot;
+    Path packages;
     if (configuration['use_repository_packages'] ||
         configuration['use_public_packages']) {
       Path pubspecYamlFile = _findPubspecYamlFile(filePath);
       if (pubspecYamlFile != null) {
         var result = buildSpecialPackageRoot(pubspecYamlFile);
         baseCommands.addAll(result['commands']);
         packageRoot = result['package-root'];
         if (optionsFromFile['packageRoot'] == null ||
             optionsFromFile['packageRoot'] == "") {
           optionsFromFile['packageRoot'] = packageRoot.toNativePath();
@@ skipping 19 matching lines @@
       if (info.optionsFromFile['isMultiHtmlTest']) {
         // A browser multi-test has multiple expectations for one test file.
         // Find all the different sub-test expecations for one entire test file.
         List<String> subtestNames = info.optionsFromFile['subtestNames'];
         Map<String, Set<Expectation>> multiHtmlTestExpectations = {};
         for (String name in subtestNames) {
           String fullTestName = '$testName/$name';
           multiHtmlTestExpectations[fullTestName] =
               testExpectations.expectations(fullTestName);
         }
-        enqueueBrowserTest(baseCommands, packageRoot, info, testName,
+        enqueueBrowserTest(baseCommands, packageRoot, packages, info, testName,
             multiHtmlTestExpectations);
       } else {
         enqueueBrowserTest(
-            baseCommands, packageRoot, info, testName, expectations);
+            baseCommands, packageRoot, packages, info, testName, expectations);
       }
     } else {
       enqueueStandardTest(baseCommands, info, testName, expectations);
     }
   }
 
   void enqueueStandardTest(List<Command> baseCommands, TestInformation info,
       String testName, Set<Expectation> expectations) {
     var commonArguments =
         commonArgumentsFromFile(info.filePath, info.optionsFromFile);
@@ skipping 180 matching lines @@
    * JavaScript version of the test, and copies the appropriate framework
    * files to that directory.  It creates a [BrowserTestCase], which has
    * two sequential steps to be run by the [ProcessQueue] when the test is
    * executed: a compilation step and an execution step, both with the
    * appropriate executable and arguments. The [expectations] object can be
    * either a Set<String> if the test is a regular test, or a Map<String
    * subTestName, Set<String>> if we are running a browser multi-test (one
    * compilation and many browser runs).
    */
   void enqueueBrowserTest(List<Command> baseCommands, Path packageRoot,
-      TestInformation info, String testName, expectations) {
+      Path packages, TestInformation info, String testName, expectations) {
     RegExp badChars = new RegExp('[-=/]');
     List VmOptionsList = getVmOptions(info.optionsFromFile);
     bool multipleOptions = VmOptionsList.length > 1;
     for (var vmOptions in VmOptionsList) {
       String optionsName =
           multipleOptions ? vmOptions.join('-').replaceAll(badChars, '') : '';
       String tempDir = createOutputDirectory(info.filePath, optionsName);
-      enqueueBrowserTestWithOptions(baseCommands, packageRoot, info, testName,
-          expectations, vmOptions, tempDir);
+      enqueueBrowserTestWithOptions(baseCommands, packageRoot, packages,
+          info, testName, expectations, vmOptions, tempDir);
     }
   }
 
   void enqueueBrowserTestWithOptions(
       List<Command> baseCommands,
       Path packageRoot,
+      Path packages,
       TestInformation info,
       String testName,
       expectations,
       List<String> vmOptions,
       String tempDir) {
     // TODO(Issue 14651): If we're on dartium, we need to pass [packageRoot]
     // on to the browser (it may be test specific).
 
     Path filePath = info.filePath;
     String filename = filePath.toString();
@@ skipping 348 matching lines @@
     if (dartOptions != null) {
       args.addAll(dartOptions);
     }
 
     return args;
   }
 
   String packagesArgument(String packageRootFromFile,
                              String packagesFromFile) {
     if (packagesFromFile != null) {
-      return "--packages=$packagesFromFile";
+      return '--packages=$packagesFromFile';
+    } else if (packageRootFromFile != null && packageRootFromFile != 'none') {
+      return '--package-root=$packageRootFromFile';
+    } else {
+    return null;
     }
-    if (packageRootFromFile == "none") {
-      return null;
-    }
-    packageRootFromFile ??= "$buildDir/packages/";
-    return "--package-root=$packageRootFromFile";
   }
 
   /**
    * Special options for individual tests are currently specified in various
    * ways: with comments directly in test files, by using certain imports, or by
    * creating additional files in the test directories.
    *
    * Here is a list of options that are used by 'test.dart' today:
    *   - Flags can be passed to the vm or dartium process that runs the test by
    *   adding a comment to the test file:
@@ skipping 232 matching lines @@
 /// Used for testing packages in on off settings, i.e., we pass in the actual
 /// directory that we want to test.
 class PKGTestSuite extends StandardTestSuite {
   PKGTestSuite(Map configuration, Path directoryPath)
       : super(configuration, directoryPath.filename, directoryPath,
             ["$directoryPath/.status"],
             isTestFilePredicate: (f) => f.endsWith('_test.dart'),
             recursive: true);
 
   void enqueueBrowserTest(List<Command> baseCommands, Path packageRoot,
-      TestInformation info, String testName, expectations) {
+      packages, TestInformation info, String testName, expectations) {
     String runtime = configuration['runtime'];
     Path filePath = info.filePath;
     Path dir = filePath.directoryPath;
     String nameNoExt = filePath.filenameWithoutExtension;
     Path customHtmlPath = dir.append('$nameNoExt.html');
     File customHtml = new File(customHtmlPath.toNativePath());
     if (!customHtml.existsSync()) {
       super.enqueueBrowserTest(
-          baseCommands, packageRoot, info, testName, expectations);
+          baseCommands, packageRoot, packages, info, testName, expectations);
     } else {
       Path relativeHtml = customHtmlPath.relativeTo(TestUtils.dartDir);
       List<Command> commands = []..addAll(baseCommands);
       var fullPath = _createUrlPathFromFile(customHtmlPath);
 
       commands.add(CommandBuilder.instance.getBrowserTestCommand(
           runtime, fullPath, configuration, !isNegative(info)));
       String testDisplayName = '$suiteName/$testName';
       enqueueNewTestCase(new BrowserTestCase(
           testDisplayName,
@@ skipping 609 matching lines @@
       }
       if (path.length > WINDOWS_SHORTEN_PATH_LIMIT) {
         ++shortNameCounter;
         var pathEnd = path.substring(path.length - WINDOWS_PATH_END_LENGTH);
         path = "short${shortNameCounter}_$pathEnd";
       }
     }
     return path;
   }
 }