Checked-in binary update to v1.0.0.3

dart/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,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 library test_suite;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:io";
-import "dart:isolate";
 import "drt_updater.dart";
 import "multitest.dart";
 import "status_file_parser.dart";
 import "test_runner.dart";
 import "utils.dart";
 import "http_server.dart" show PREFIX_BUILDDIR, PREFIX_DARTDIR;
 
 part "browser_test.dart";
 
 
@@ skipping 289 matching lines @@
     }
 
     var testName = "$directory";
     testName = concat(testName, "$filenameWithoutExt");
     testName = concat(testName, multitestName);
     return testName;
   }
 }
 
 
-void ccTestLister() {
-  port.receive((String runnerPath, SendPort replyTo) {
-    Future processFuture = Process.start(runnerPath, ["--list"]);
-    processFuture.then((Process p) {
-      // Drain stderr to not leak resources.
-      p.stderr.listen((_) { });
-      Stream<String> stdoutStream =
-          p.stdout.transform(UTF8.decoder)
-                  .transform(new LineSplitter());
-      var streamDone = false;
-      var processExited = false;
-      checkDone() {
-        if (streamDone && processExited) {
-          replyTo.send("");
-        }
-      }
-      stdoutStream.listen((String line) {
-        replyTo.send(line);
-      },
-      onDone: () {
-        streamDone = true;
-        checkDone();
-      });
-
-      p.exitCode.then((code) {
-        if (code < 0) {
-          print("Failed to list tests: $runnerPath --list");
-          replyTo.send("");
-        } else {
-          processExited = true;
-          checkDone();
-        }
-      });
-      port.close();
-    }).catchError((e) {
-      print("Failed to list tests: $runnerPath --list");
-      replyTo.send("");
-      return true;
-    });
+Future<Iterable<String>> ccTestLister(String runnerPath) {
+  return Process.run(runnerPath, ["--list"]).then((ProcessResult result) {
+    if (result.exitCode != 0) {
+      throw "Failed to list tests: '$runnerPath --list'. "
+            "Process exited with ${result.exitCode}";
+    }
+    return result.stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .where((name) => name.length > 0);
   });
 }
 
 
 /**
  * A specialized [TestSuite] that runs tests written in C to unit test
  * the Dart virtual machine and its API.
  *
  * The tests are compiled into a monolithic executable by the build step.
  * The executable lists its tests when run with the --list command line flag.
  * Individual tests are run by specifying them on the command line.
  */
 class CCTestSuite extends TestSuite {
   final String testPrefix;
   String targetRunnerPath;
   String hostRunnerPath;
   final String dartDir;
   List<String> statusFilePaths;
   VoidFunction doDone;
-  ReceivePort receiveTestName;
   TestExpectations testExpectations;
 
   CCTestSuite(Map configuration,
               String suiteName,
               String runnerName,
               List<String> this.statusFilePaths,
               {this.testPrefix: ''})
       : super(configuration, suiteName),
         dartDir = TestUtils.dartDir().toNativePath() {
     // For running the tests we use the given '$runnerName' binary
     targetRunnerPath = '$buildDir/$runnerName';
 
     // For listing the tests we use the '$runnerName.host' binary if it exists
     // and use '$runnerName' if it doesn't.
     var binarySuffix = Platform.operatingSystem == 'windows' ? '.exe' : '';
     var hostBinary = '$targetRunnerPath.host$binarySuffix';
     if (new File(hostBinary).existsSync()) {
       hostRunnerPath = hostBinary;
     } else {
       hostRunnerPath = targetRunnerPath;
     }
   }
 
-  void testNameHandler(String testName, ignore) {
-    if (testName == "") {
-      receiveTestName.close();
+  void testNameHandler(String testName) {
+    // Only run the tests that match the pattern. Use the name
+    // "suiteName/testName" for cc tests.
+    String constructedName = '$suiteName/$testPrefix$testName';
 
-      if (doDone != null) doDone();
-    } else {
-      // Only run the tests that match the pattern. Use the name
-      // "suiteName/testName" for cc tests.
-      String constructedName = '$suiteName/$testPrefix$testName';
+    var expectations = testExpectations.expectations(
+        '$testPrefix$testName');
 
-      var expectations = testExpectations.expectations(
-          '$testPrefix$testName');
+    var args = TestUtils.standardOptions(configuration);
+    args.add(testName);
 
-      var args = TestUtils.standardOptions(configuration);
-      args.add(testName);
-
-      var command = CommandBuilder.instance.getCommand(
-          'run_vm_unittest', targetRunnerPath, args, configurationDir);
-      enqueueNewTestCase(
-          new TestCase(constructedName,
-                       [command],
-                       configuration,
-                       expectations));
-    }
+    var command = CommandBuilder.instance.getCommand(
+        'run_vm_unittest', targetRunnerPath, args, configurationDir);
+    enqueueNewTestCase(
+        new TestCase(constructedName, [command], configuration, expectations));
   }
 
   void forEachTest(Function onTest, Map testCache, [VoidFunction onDone]) {
     doTest = onTest;
     doDone = onDone;
 
     var filesRead = 0;
     void statusFileRead() {
       filesRead++;
       if (filesRead == statusFilePaths.length) {
-        receiveTestName = new ReceivePort();
-        var port = spawnFunction(ccTestLister);
-        port.send(hostRunnerPath, receiveTestName.toSendPort());
-        receiveTestName.receive(testNameHandler);
+        ccTestLister(hostRunnerPath).then((Iterable<String> names) {
+          names.forEach(testNameHandler);
+          onDone();
+        }).catchError((error) {
+          print("Fatal error occured: $error");
+          exit(1);
+        });
       }
     }
 
     testExpectations = new TestExpectations();
     for (var statusFilePath in statusFilePaths) {
       ReadTestExpectationsInto(testExpectations,
                                '$dartDir/$statusFilePath',
                                configuration,
                                statusFileRead);
     }
@@ skipping 766 matching lines @@
     if (!optionsName.isEmpty) {
       testUniqueName = '$testUniqueName-$optionsName';
     }
 
     Path generatedTestPath = new Path(buildDir)
         .append('generated_$name')
         .append(dirname)
         .append(testUniqueName);
 
     TestUtils.mkdirRecursive(new Path('.'), generatedTestPath);
-    return new File(generatedTestPath.toNativePath()).fullPathSync()
+    return new File(generatedTestPath.toNativePath()).absolute.path
         .replaceAll('\\', '/');
   }
 
   String get scriptType {
     switch (configuration['compiler']) {
       case 'none':
       case 'dart2dart':
         return 'application/dart';
       case 'dart2js':
       case 'dartanalyzer':
@@ skipping 455 matching lines @@
 
     // Lengthen the timeout for JUnit tests.  It is normal for them
     // to run for a few minutes.
     Map updatedConfiguration = new Map();
     configuration.forEach((key, value) {
       updatedConfiguration[key] = value;
     });
     updatedConfiguration['timeout'] *= 3;
     var command = CommandBuilder.instance.getCommand(
         'junit_test', 'java', args, configurationDir);
-    enqueueNewTestCase(new TestCase(suiteName,
-                                   [command],
-                                   updatedConfiguration,
-                                   new Set<String>.from([PASS])));
+    enqueueNewTestCase(
+        new TestCase(suiteName,
+                     [command],
+                     updatedConfiguration,
+                     new Set<Expectation>.from([Expectation.PASS])));
     doDone();
   }
 
   void computeClassPath() {
     classPath =
         ['$buildDir/analyzer/util/analyzer/dart_analyzer.jar',
          '$buildDir/analyzer/dart_analyzer_tests.jar',
          // Third party libraries.
          '$dartDir/third_party/args4j/2.0.12/args4j-2.0.12.jar',
          '$dartDir/third_party/guava/r13/guava-13.0.1.jar',
@@ skipping 32 matching lines @@
   }
 }
 
 class TestUtils {
   /**
    * The libraries in this directory relies on finding various files
    * relative to the 'test.dart' script in '.../dart/tools/test.dart'. If
    * the main script using 'test_suite.dart' is not there, the main
    * script must set this to '.../dart/tools/test.dart'.
    */
-  static String testScriptPath = new Options().script;
+  static String testScriptPath = Platform.script.path;
   static LastModifiedCache lastModifiedCache = new LastModifiedCache();
   static Path currentWorkingDirectory =
       new Path(Directory.current.path);
   /**
    * Creates a directory using a [relativePath] to an existing
    * [base] directory if that [relativePath] does not already exist.
    */
   static Directory mkdirRecursive(Path base, Path relativePath) {
     if (relativePath.isAbsolute) {
       base = new Path('/');
@@ skipping 61 matching lines @@
     } else if (system == 'macos') {
       result = 'xcodebuild/';
     } else if (system == 'windows') {
       result = 'build/';
     }
     return result;
   }
 
   static Path dartDir() {
     File scriptFile = new File(testScriptPath);
-    Path scriptPath = new Path(scriptFile.fullPathSync());
+    Path scriptPath = new Path(scriptFile.absolute.path);
     return scriptPath.directoryPath.directoryPath;
   }
 
   static List<String> standardOptions(Map configuration) {
     List args = ["--ignore-unrecognized-flags"];
     if (configuration["checked"]) {
       args.add('--enable_asserts');
       args.add("--enable_type_checks");
     }
     String compiler = configuration["compiler"];
@@ skipping 163 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);
    }
 }