Migration of testing scripts in tools/ to libv2

tools/testing/dart/test_runner.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 executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
  */
 library test_runner;
 
-import "dart:io";
+import "dart:async";
+// We need to use the 'io' prefix here, otherwise io.exitCode will shadow
+// CommandOutput.exitCode in subclasses of CommandOutput.
+import "dart:io" as io;
 import "dart:isolate";
 import "dart:uri";
 import "status_file_parser.dart";
 import "test_progress.dart";
 import "test_suite.dart";
 
 const int NO_TIMEOUT = 0;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 
 typedef void TestCaseEvent(TestCase testCase);
@@ skipping 57 matching lines @@
   /** Command line arguments to the executable. */
   List<String> arguments;
 
   /** Environment for the command */
   Map<String,String> environment;
 
   /** The actual command line that will be executed. */
   String commandLine;
 
   Command(this.executable, this.arguments, [this.environment = null]) {
-    if (Platform.operatingSystem == 'windows') {
+    if (io.Platform.operatingSystem == 'windows') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
       // TODO(efortuna): Remove this when fixed (Issue 1306).
       executable = executable.replaceAll('/', '\\');
     }
     commandLine = "$executable ${Strings.join(arguments, ' ')}";
   }
 
   String toString() => commandLine;
 
   Future<bool> get outputIsUpToDate => new Future.immediate(false);
-  Path get expectedOutputFile => null;
+  io.Path get expectedOutputFile => null;
   bool get isPixelTest => false;
 }
 
 class CompilationCommand extends Command {
   String _outputFile;
   bool _neverSkipCompilation;
   List<Uri> _bootstrapDependencies;
 
   CompilationCommand(this._outputFile,
                      this._neverSkipCompilation,
                      this._bootstrapDependencies,
                      String executable,
                      List<String> arguments)
       : super(executable, arguments);
 
   Future<bool> get outputIsUpToDate {
     if (_neverSkipCompilation) return new Future.immediate(false);
 
     Future<List<Uri>> readDepsFile(String path) {
-      var file = new File(new Path(path).toNativePath());
+      var file = new io.File(new io.Path(path).toNativePath());
       if (!file.existsSync()) {
         return new Future.immediate(null);
       }
-      return file.readAsLines().transform((List<String> lines) {
+      return file.readAsLines().then((List<String> lines) {
         var dependencies = new List<Uri>();
         for (var line in lines) {
           line = line.trim();
           if (line.length > 0) {
             dependencies.add(new Uri(line));
           }
         }
         return dependencies;
       });
     }
 
-    return readDepsFile("$_outputFile.deps").transform((dependencies) {
+    return readDepsFile("$_outputFile.deps").then((dependencies) {
       if (dependencies != null) {
         dependencies.addAll(_bootstrapDependencies);
         var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
             new Uri.fromComponents(scheme: 'file', path: _outputFile));
         if (jsOutputLastModified != null) {
           for (var dependency in dependencies) {
             var dependencyLastModified =
                 TestUtils.lastModifiedCache.getLastModified(dependency);
             if (dependencyLastModified == null ||
                 dependencyLastModified > jsOutputLastModified) {
               return false;
             }
           }
           return true;
         }
       }
       return false;
     });
   }
 }
 
 class DumpRenderTreeCommand extends Command {
   /**
    * If [expectedOutputPath] is set, the output of DumpRenderTree is compared
    * with the content of [expectedOutputPath].
    * This is used for example for pixel tests, where [expectedOutputPath] points
    * to a *png file.
    */
-  Path expectedOutputPath;
+  io.Path expectedOutputPath;
 
   DumpRenderTreeCommand(String executable,
                         String htmlFile,
                         List<String> options,
                         List<String> dartFlags,
                         Uri packageRootUri,
-                        Path this.expectedOutputPath)
+                        io.Path this.expectedOutputPath)
       : super(executable,
               _getArguments(options, htmlFile),
               _getEnvironment(dartFlags, packageRootUri));
 
   static Map _getEnvironment(List<String> dartFlags, Uri packageRootUri) {
     var needDartFlags = dartFlags != null && dartFlags.length > 0;
     var needDartPackageRoot = packageRootUri != null;
 
     var env = null;
     if (needDartFlags || needDartPackageRoot) {
-      env = new Map.from(Platform.environment);
+      env = new Map.from(io.Platform.environment);
       if (needDartFlags) {
         env['DART_FLAGS'] = Strings.join(dartFlags, " ");
       }
       if (needDartPackageRoot) {
         env['DART_PACKAGE_ROOT'] = packageRootUri.toString();
       }
     }
 
     return env;
   }
 
   static List<String> _getArguments(List<String> options, String htmlFile) {
     var arguments = new List.from(options);
     arguments.add(htmlFile);
     return arguments;
   }
 
-  Path get expectedOutputFile => expectedOutputPath;
+  io.Path get expectedOutputFile => expectedOutputPath;
   bool get isPixelTest => (expectedOutputFile != null &&
                            expectedOutputFile.filename.endsWith(".png"));
 }
 
 
 /**
  * TestCase contains all the information needed to run a test and evaluate
  * its output.  Running a test involves starting a separate process, with
  * the executable and arguments given by the TestCase, and recording its
  * stdout and stderr output streams, and its exit code.  TestCase only
@@ skipping 332 matching lines @@
 
   String get result =>
       hasCrashed ? CRASH : (hasTimedOut ? TIMEOUT : (hasFailed ? FAIL : PASS));
 
   bool get unexpectedOutput => !testCase.expectedOutcomes.contains(result);
 
   bool get hasCrashed {
     // The Java dartc runner and dart2js exits with code 253 in case
     // of unhandled exceptions.
     if (exitCode == 253) return true;
-    if (Platform.operatingSystem == 'windows') {
+    if (io.Platform.operatingSystem == 'windows') {
       // The VM uses std::abort to terminate on asserts.
       // std::abort terminates with exit code 3 on Windows.
       if (exitCode == 3) {
         return !timedOut;
       }
       return (!timedOut && (exitCode < 0) && ((0x3FFFFF00 & exitCode) == 0));
     }
     return !timedOut && ((exitCode < 0));
   }
 
@@ skipping 82 matching lines @@
      *     Content-Length: ...\n
      *     <*png data>
      *     #EOF\n
      * So we need to get the byte-range of the png data first, before
      * comparing it with the content of the expected output file.
      *
      * On a layout tests, the DRT output is directly compared with the
      * content of the expected output.
      */
     var stdout = testCase.commandOutputs[command].stdout;
-    var file = new File.fromPath(command.expectedOutputFile);
+    var file = new io.File.fromPath(command.expectedOutputFile);
     if (file.existsSync()) {
       var bytesContentLength = "Content-Length:".charCodes;
       var bytesNewLine = "\n".charCodes;
       var bytesEOF = "#EOF\n".charCodes;
 
       var expectedContent = file.readAsBytesSync();
       if (command.isPixelTest) {
         var startOfContentLength = findBytes(stdout, bytesContentLength);
         if (startOfContentLength >= 0) {
           var newLineAfterContentLength = findBytes(stdout,
@@ skipping 236 matching lines @@
  * its [TestCase], starting the test process (and first, a compilation
  * process if the TestCase is a [BrowserTestCase]), creating a timeout
  * timer, and recording the results in a new [CommandOutput] object, which it
  * attaches to the TestCase.  The lifetime of the RunningProcess is limited
  * to the time it takes to start the process, run the process, and record
  * the result; there are no pointers to it, so it should be available to
  * be garbage collected as soon as it is done.
  */
 class RunningProcess {
   ProcessQueue processQueue;
-  Process process;
+  io.Process process;
   TestCase testCase;
   bool timedOut = false;
   Date startTime;
   Timer timeoutTimer;
   List<int> stdout;
   List<int> stderr;
   List<String> notifications;
   bool compilationSkipped;
   bool allowRetries;
 
@@ skipping 117 matching lines @@
     return commandOutput;
   }
 
   void resetLocalOutputInformation() {
     stdout = new List<int>();
     stderr = new List<int>();
     notifications = new List<String>();
     compilationSkipped = false;
   }
 
-  void drainStream(InputStream source, List<int> destination) {
+  void drainStream(io.InputStream source, List<int> destination) {
     void onDataHandler () {
       if (source.closed) {
         return;  // TODO(whesse): Remove when bug is fixed.
       }
       var data = source.read();
       while (data != null) {
         destination.addAll(data);
         data = source.read();
       }
     }
@@ skipping 14 matching lines @@
       commandCompleteHandler(command, returnCode);
     }
 
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         notifications.add("Skipped compilation because the old output is "
                           "still up to date!");
         compilationSkipped = true;
         commandComplete(command, 0);
       } else {
-        ProcessOptions options = new ProcessOptions();
+        io.ProcessOptions options = new io.ProcessOptions();
         if (command.environment != null) {
           options.environment =
               new Map<String, String>.from(command.environment);
         } else {
           options.environment =
-              new Map<String, String>.from(Platform.environment);
+              new Map<String, String>.from(io.Platform.environment);
         }
 
         options.environment['DART_CONFIGURATION'] =
             TestUtils.configurationDir(testCase.configuration);
-        Future processFuture = Process.start(command.executable,
+        Future processFuture = io.Process.start(command.executable,
                                              command.arguments,
                                              options);
-        processFuture.then((Process p) {
+        processFuture.then((io.Process p) {
           process = p;
           process.onExit = processExitHandler;
           drainStream(process.stdout, stdout);
           drainStream(process.stderr, stderr);
           if (timeoutTimer == null) {
             // Create one timeout timer when starting test case, remove it at
             // the end.
             timeoutTimer = new Timer(1000 * testCase.timeout, timeoutHandler);
           }
           // If the timeout fired in between two commands, kill the just
           // started process immediately.
           if (timedOut) safeKill(process);
-        });
-        processFuture.handleException((e) {
+        }).catchError((e) {
           print("Process error:");
           print("  Command: $command");
           print("  Error: $e");
           testComplete(createCommandOutput(command, -1, false));
           return true;
         });
       }
     });
   }
 
   void timeoutHandler(Timer unusedTimer) {
     timedOut = true;
     safeKill(process);
   }
 
-  void safeKill(Process p) {
+  void safeKill(io.Process p) {
     if (p != null) {
       try {
         p.kill();
-      } on ProcessException {
+      } on io.ProcessException {
         // Hopefully, this means that the process died on its own.
       }
     }
   }
 }
 
 /**
  * This class holds a value, that can be changed.  It is used when
  * closures need a shared value, that they can all change and read.
  */
 class MutableValue<T> {
   MutableValue(T this.value);
   T value;
 }
 
 class BatchRunnerProcess {
   Command _command;
   String _executable;
   List<String> _batchArguments;
 
-  Process _process;
-  StringInputStream _stdoutStream;
-  StringInputStream _stderrStream;
+  io.Process _process;
+  io.StringInputStream _stdoutStream;
+  io.StringInputStream _stderrStream;
 
   TestCase _currentTest;
   List<int> _testStdout;
   List<int> _testStderr;
   String _status;
   bool _stdoutDrained = false;
   bool _stderrDrained = false;
   MutableValue<bool> _ignoreStreams;
   Date _startTime;
   Timer _timer;
@@ skipping 118 matching lines @@
     // Move on when both stdout and stderr has been drained.
     if (_stdoutDrained) _reportResult();
   }
 
   void _stdoutDone() {
     _stdoutDrained = true;
     // Move on when both stdout and stderr has been drained.
     if (_stderrDrained) _reportResult();
   }
 
-  void _readStdout(StringInputStream stream, List<int> buffer) {
+  void _readStdout(io.StringInputStream stream, List<int> buffer) {
     var ignoreStreams = _ignoreStreams;  // Capture this mutable object.
     void onLineHandler() {
       if (ignoreStreams.value) {
          while (stream.readLine() != null) {
           // Do nothing.
         }
         return;
       }
       // Otherwise, process output and call _reportResult() when done.
       var line = stream.readLine();
@@ skipping 10 matching lines @@
         line = stream.readLine();
       }
       if (_status != null) {
         _timer.cancel();
         _stdoutDone();
       }
     }
     stream.onLine = onLineHandler;
   }
 
-  void _readStderr(StringInputStream stream, List<int> buffer) {
+  void _readStderr(io.StringInputStream stream, List<int> buffer) {
     var ignoreStreams = _ignoreStreams;  // Capture this mutable object.
     void onLineHandler() {
       if (ignoreStreams.value) {
         while (stream.readLine() != null) {
           // Do nothing.
         }
         return;
       }
       // Otherwise, process output and call _reportResult() when done.
       var line = stream.readLine();
@@ skipping 35 matching lines @@
     }
     return handler;
   }
 
   void _timeoutHandler(ignore) {
     _process.onExit = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
-    Future processFuture = Process.start(_executable, _batchArguments);
-    processFuture.then((Process p) {
+    Future processFuture = io.Process.start(_executable, _batchArguments);
+    processFuture.then((io.Process p) {
       _process = p;
-      _stdoutStream = new StringInputStream(_process.stdout);
-      _stderrStream = new StringInputStream(_process.stderr);
+      _stdoutStream = new io.StringInputStream(_process.stdout);
+      _stderrStream = new io.StringInputStream(_process.stderr);
       _process.onExit = makeExitHandler(">>> TEST CRASH");
       callback();
-    });
-    processFuture.handleException((e) {
+    }).catchError((e) {
       print("Process error:");
       print("  Command: $_executable ${Strings.join(_batchArguments, ' ')}");
       print("  Error: $e");
       // If there is an error starting a batch process, chances are that
       // it will always fail. So rather than re-trying a 1000+ times, we
       // exit.
       exit(1);
       return true;
     });
   }
@@ skipping 38 matching lines @@
   /**
    * String indicating the browser used to run the tests. Empty if no browser
    * used.
    */
   String browserUsed = '';
 
   /**
    * Process running the selenium server .jar (only used for Safari and Opera
    * tests.)
    */
-  Process _seleniumServer = null;
+  io.Process _seleniumServer = null;
 
   /** True if we are in the process of starting the server. */
   bool _startingServer = false;
 
   /** True if we find that there is already a selenium jar running. */
   bool _seleniumAlreadyRunning = false;
 
   ProcessQueue(int this._maxProcesses,
                String progress,
                Date startTime,
@@ skipping 51 matching lines @@
       if (_tests.isEmpty && _numProcesses == 0) {
         _terminateBatchRunners().then((_) => _cleanupAndMarkDone());
       }
     }
   }
 
   /**
    * True if we are using a browser + platform combination that needs the
    * Selenium server jar.
    */
-  bool get _needsSelenium => (Platform.operatingSystem == 'macos' &&
+  bool get _needsSelenium => (io.Platform.operatingSystem == 'macos' &&
       browserUsed == 'safari') || browserUsed == 'opera';
 
   /** True if the Selenium Server is ready to be used. */
   bool get _isSeleniumAvailable => _seleniumServer != null ||
       _seleniumAlreadyRunning;
 
   /**
    * Restart all the processes that have been waiting/stopped for the server to
    * start up. If we just call this once we end up with a single-"threaded" run.
    */
   void resumeTesting() {
     for (int i = 0; i < _maxProcesses; i++) _tryRunTest();
   }
 
   /** Start the Selenium Server jar, if appropriate for this platform. */
   void _ensureSeleniumServerRunning() {
     if (!_isSeleniumAvailable && !_startingServer) {
       _startingServer = true;
 
       // Check to see if the jar was already running before the program started.
       String cmd = 'ps';
       var arg = ['aux'];
-      if (Platform.operatingSystem == 'windows') {
+      if (io.Platform.operatingSystem == 'windows') {
         cmd = 'tasklist';
         arg.add('/v');
       }
 
-      Future processFuture = Process.start(cmd, arg);
-      processFuture.then((Process p) {
+      Future processFuture = io.Process.start(cmd, arg);
+      processFuture.then((io.Process p) {
         // Drain stderr to not leak resources.
         p.stderr.onData = p.stderr.read;
-        final StringInputStream stdoutStringStream =
-            new StringInputStream(p.stdout);
+        final io.StringInputStream stdoutStringStream =
+            new io.StringInputStream(p.stdout);
         stdoutStringStream.onLine = () {
           var line = stdoutStringStream.readLine();
           while (null != line) {
             var regexp = new RegExp(r".*selenium-server-standalone.*");
             if (regexp.hasMatch(line)) {
               _seleniumAlreadyRunning = true;
               resumeTesting();
             }
             line = stdoutStringStream.readLine();
           }
           if (!_isSeleniumAvailable) {
             _startSeleniumServer();
           }
         };
-      });
-      processFuture.handleException((e) {
+      }).catchError((e) {
         print("Error starting process:");
         print("  Command: $cmd ${Strings.join(arg, ' ')}");
         print("  Error: $e");
         // TODO(ahe): How to report this as a test failure?
         exit(1);
         return true;
       });
     }
   }
 
   void _runTest(TestCase test) {
     if (test.usesWebDriver) {
       browserUsed = test.configuration['browser'];
       if (_needsSelenium) _ensureSeleniumServerRunning();
     }
     _progress.testAdded();
     _tests.add(test);
     _tryRunTest();
   }
 
   /**
    * Monitor the output of the Selenium server, to know when we are ready to
    * begin running tests.
    * source: Output(Stream) from the Java server.
    */
-  VoidFunction makeSeleniumServerHandler(StringInputStream source) {
+  VoidFunction makeSeleniumServerHandler(io.StringInputStream source) {
     void handler() {
       if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
       var line = source.readLine();
       while (null != line) {
         if (new RegExp(r".*Started.*Server.*").hasMatch(line) ||
             new RegExp(r"Exception.*Selenium is already running.*").hasMatch(
             line)) {
           resumeTesting();
         }
         line = source.readLine();
       }
     }
     return handler;
   }
 
   /**
    * For browser tests using Safari or Opera, we need to use the Selenium 1.0
    * Java server.
    */
   void _startSeleniumServer() {
     // Get the absolute path to the Selenium jar.
     String filePath = TestUtils.testScriptPath;
-    String pathSep = Platform.pathSeparator;
+    String pathSep = io.Platform.pathSeparator;
     int index = filePath.lastIndexOf(pathSep);
     filePath = '${filePath.substring(0, index)}${pathSep}testing${pathSep}';
-    var lister = new Directory(filePath).list();
+    var lister = new io.Directory(filePath).list();
     lister.onFile = (String file) {
       if (new RegExp(r"selenium-server-standalone-.*\.jar").hasMatch(file)
           && _seleniumServer == null) {
-        Future processFuture = Process.start('java', ['-jar', file]);
-        processFuture.then((Process server) {
+        Future processFuture = io.Process.start('java', ['-jar', file]);
+        processFuture.then((io.Process server) {
           _seleniumServer = server;
           // Heads up: there seems to an obscure data race of some form in
           // the VM between launching the server process and launching the test
           // tasks that disappears when you read IO (which is convenient, since
           // that is our condition for knowing that the server is ready).
-          StringInputStream stdoutStringStream =
-              new StringInputStream(_seleniumServer.stdout);
-          StringInputStream stderrStringStream =
-              new StringInputStream(_seleniumServer.stderr);
+          io.StringInputStream stdoutStringStream =
+              new io.StringInputStream(_seleniumServer.stdout);
+          io.StringInputStream stderrStringStream =
+              new io.StringInputStream(_seleniumServer.stderr);
           stdoutStringStream.onLine =
               makeSeleniumServerHandler(stdoutStringStream);
           stderrStringStream.onLine =
               makeSeleniumServerHandler(stderrStringStream);
-        });
-        processFuture.handleException((e) {
+        }).catchError((e) {
           print("Process error:");
           print("  Command: java -jar $file");
           print("  Error: $e");
           // TODO(ahe): How to report this as a test failure?
           exit(1);
           return true;
         });
       }
     };
   }
@@ skipping 79 matching lines @@
         // the developer doesn't waste his or her time trying to fix a bunch of
         // tests that appear to be broken but were actually just flakes that
         // didn't get retried because there had already been one failure.
         bool allowRetry = _MAX_FAILED_NO_RETRY > _progress.numFailedTests;
         new RunningProcess(test, allowRetry, this).start();
       }
       _numProcesses++;
     }
   }
 }