Make the "pub" and "pkg" test suites run Dart from the built SDK.

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 86 matching lines @@
  * Most TestSuites represent a directory or directory tree containing tests,
  * and a status file containing the expected results when these tests are run.
  */
 abstract class TestSuite {
   final Map configuration;
   final String suiteName;
 
   TestSuite(this.configuration, this.suiteName);
 
   /**
+   * Whether or not binaries should be found in the root build directory or
+   * in the built SDK.
+   */
+  bool get useSdk {

[Emily Fortuna, 2013/01/04 21:39:10]

can we add a little TODO here that says that we plan to switch all tests to run
with the SDK eventually, so this code should go away? 

[Bob Nystrom, 2013/01/04 22:29:45]

Done.

+    // Some suites always use the SDK.
+    if (['pkg', 'pub'].contains(suiteName)) return true;
+
+    return configuration['use_sdk'];
+  }
+
+  /**
    * The output directory for this suite's configuration.
    */
   String get buildDir => TestUtils.buildDir(configuration);
 
   /**
    * The path to the compiler for this suite's configuration. Returns `null` if
    * no compiler should be used.
    */
   String get compilerPath {
     if (configuration['compiler'] == 'none') {
       return null;  // No separate compiler for dartium tests.
     }
     var name;
     switch (configuration['compiler']) {
       case 'dartc':
-        name = '$buildDir/$executableName';
+        name = executablePath;
       case 'dart2js':
       case 'dart2dart':
         var prefix = 'sdk/bin/';
         String suffix = getExecutableSuffix(configuration['compiler']);
         if (configuration['host_checked']) {
           // The script dart2js_developer is not included in the
           // shipped SDK, that is the script is not installed in
           // "$buildDir/dart-sdk/bin/"
           name = '$prefix/dart2js_developer$suffix';
         } else {
           if (configuration['use_sdk']) {
             prefix = '$buildDir/dart-sdk/bin/';
           }
           name = '${prefix}dart2js$suffix';
         }
         break;
       default:
         throw "Unknown compiler for: ${configuration['compiler']}";
     }
     if (!(new File(name)).existsSync() && !configuration['list']) {
       throw "Executable '$name' does not exist";
     }
     return name;
   }
 
   /**
-   * The file name of the executable used to run this suite's tests.
+   * The path to the executable used to run this suite's tests.
    */
-  String get executableName {
-    String suffix = getExecutableSuffix(configuration['compiler']);
+  String get executablePath {
+    var suffix = getExecutableSuffix(configuration['compiler']);
     switch (configuration['compiler']) {
       case 'none':
-        return 'dart$suffix';
+        if (useSdk) {
+          return '$buildDir/dart-sdk/bin/dart$suffix';
+        }
+        return '$buildDir/dart$suffix';
       case 'dartc':
-        return 'analyzer/bin/dart_analyzer$suffix';
+        return '$buildDir/analyzer/bin/dart_analyzer$suffix';
       default:
         throw "Unknown executable for: ${configuration['compiler']}";
     }
   }
 
   /**
    * The file name of the d8 executable.
    */
   String get d8FileName {
     var suffix = getExecutableSuffix('d8');
     var d8 = '$buildDir/d8$suffix';
     TestUtils.ensureExists(d8, configuration);
     return d8;
   }
 
   String get dartShellFileName {
     var name = configuration['dart'];
     if (name == '') {
-      name = '$buildDir/$executableName';
+      name = executablePath;
     }
+
     TestUtils.ensureExists(name, configuration);
     return name;
   }
 
   String get jsShellFileName {
     var executableSuffix = getExecutableSuffix('jsshell');
     var executable = 'jsshell$executableSuffix';
     var jsshellDir = '${TestUtils.dartDir()}/tools/testing/bin';
     return '$jsshellDir/$executable';
   }
@@ skipping 240 matching lines @@
     final name = directory.filename;
 
     return new StandardTestSuite(configuration,
         name, directory,
         ['$directory/$name.status', '$directory/${name}_dart2js.status'],
         isTestFilePredicate: (filename) => filename.endsWith('_test.dart'),
         recursive: true);
   }
 
   Collection<Uri> get dart2JsBootstrapDependencies {
-    if (!useDart2JsFromSdk) return [];
+    if (!useSdk) return [];
 
     var snapshotPath = TestUtils.absolutePath(new Path(buildDir).join(
         new Path('dart-sdk/lib/_internal/compiler/'
                  'implementation/dart2js.dart.snapshot'))).toString();
     return [new Uri.fromComponents(scheme: 'file', path: snapshotPath)];
   }
 
-  bool get useDart2JsFromSdk {
-    return configuration['use_sdk'];
-  }
-
   /**
    * The default implementation assumes a file is a test if
    * it ends in "Test.dart".
    */
   bool isTestFile(String filename) {
     // Use the specified predicate, if provided.
     if (isTestFilePredicate != null) return isTestFilePredicate(filename);
 
     return filename.endsWith("Test.dart");
   }
@@ skipping 237 matching lines @@
     }
   }
 
   List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
     switch (configuration['compiler']) {
     case 'dart2js':
       args = new List.from(args);
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.js');
 
-       List<Command> commands = 
+       List<Command> commands =
            <Command>[new CompilationCommand("$tempDir/out.js",
-                                            !useDart2JsFromSdk,
+                                            !useSdk,
                                             dart2JsBootstrapDependencies,
                                             compilerPath,
                                             args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'd8') {
         commands.add(new Command(d8FileName, ['$tempDir/out.js']));
       } else if (configuration['runtime'] == 'jsshell') {
         commands.add(new Command(jsShellFileName, ['$tempDir/out.js']));
       }
       return commands;
 
     case 'dart2dart':
       args = new List.from(args);
       args.add('--output-type=dart');
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.dart');
 
       List<Command> commands =
           <Command>[new CompilationCommand("$tempDir/out.dart",
-                                           !useDart2JsFromSdk,
+                                           !useSdk,
                                            dart2JsBootstrapDependencies,
                                            compilerPath,
                                            args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
         vmArguments.addAll([
@@ skipping 173 matching lines @@
       }
 
       // Variables for browser multi-tests.
       List<String> subtestNames = info.optionsFromFile['subtestNames'];
       TestCase multitestParentTest;
       int subtestIndex = 0;
       // Construct the command that executes the browser test
       do {
         List<Command> commandSet = new List<Command>.from(commands);
         if (subtestIndex != 0) {
-          // NOTE: The first time we enter this loop, all the compilation 
-          // commands will be executed. On subsequent loop iterations, we 
+          // NOTE: The first time we enter this loop, all the compilation
+          // commands will be executed. On subsequent loop iterations, we
           // don't need to do any compilations. Thus we set "commandSet = []".
           commandSet = [];
         }
 
         List<String> args = <String>[];
         String fullHtmlPath = htmlPath.startsWith('http:') ? htmlPath :
             (htmlPath.startsWith('/') ?
              'file://$htmlPath' :
              'file:///$htmlPath');
         if (info.optionsFromFile['isMultiHtmlTest']
@@ skipping 27 matching lines @@
             dartFlags.add('--ignore-unrecognized-flags');
             if (configuration["checked"]) {
               dartFlags.add('--enable_asserts');
               dartFlags.add("--enable_type_checks");
             }
             dartFlags.addAll(vmOptions);
           }
           if (compiler == 'none') {
             var packageRootPath = packageRoot(optionsFromFile['packageRoot']);
             if (packageRootPath != null) {
-              var absolutePath = 
+              var absolutePath =
                   TestUtils.absolutePath(new Path(packageRootPath));
               packageRootUri = new Uri.fromComponents(
                   scheme: 'file',
                   path: absolutePath.toString());
             }
           }
 
           if (expectedOutput != null) {
             if (expectedOutput.toNativePath().endsWith('.png')) {
               // pixel tests are specified by running DRT "foo.html'-p"
@@ skipping 55 matching lines @@
       default:
         Expect.fail('unimplemented compiler $compiler');
     }
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insertRange(0, 1, executable);
       executable = dartShellFileName;
     }
     if (['dart2js', 'dart2dart'].contains(configuration['compiler'])) {
       return new CompilationCommand(outputFile,
-                                   !useDart2JsFromSdk,
+                                   !useSdk,
                                    dart2JsBootstrapDependencies,
                                    compilerPath,
                                    args);
     }
     return new Command(executable, args);
   }
 
   /**
    * Create a directory for the generated test.  If a Dart language test
    * needs to be run in a browser, the Dart test needs to be embedded in
@@ skipping 732 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }