Fix whitespace, long lines, and "boolean".

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.
@@ skipping 153 matching lines @@
       _lastArguments.getRange(1, _lastArguments.length - 1);
 }
 
 
 /**
  * TestOutput records the output of a completed test: the process's exit code,
  * the standard output and standard error, whether the process timed out, and
  * the time the process took to run.  It also contains a pointer to the
  * [TestCase] this is the output of.
  */
-interface TestOutput default TestOutputImpl { 
+interface TestOutput default TestOutputImpl {
   TestOutput.fromCase(TestCase testCase, int exitCode, bool timedOut,
     List<String> stdout, List<String> stderr, Duration time);
 
   String get result();
 
   bool get unexpectedOutput();
 
   bool get hasCrashed();
 
-  bool get hasTimedOut(); 
+  bool get hasTimedOut();
 
   bool get didFail();
 
   List<String> get diagnostics();
 }
 
 class TestOutputImpl implements TestOutput {
   TestCase testCase;
   int exitCode;
   bool timedOut;
   bool failed = false;
   List<String> stdout;
   List<String> stderr;
   Duration time;
   List<String> diagnostics;
 
   /**
    * Set to true if we encounter a condition in the output that indicates we
    * need to rerun this test.
    */
   bool requestRetry = false;
 
-  // Don't call  this constructor, call TestOutput.fromCase() to 
+  // Don't call  this constructor, call TestOutput.fromCase() to
   // get anew TestOutput instance.
   TestOutputImpl(this.testCase, this.exitCode, this.timedOut, this.stdout,
              this.stderr, this.time) {
     testCase.output = this;
     diagnostics = [];
   }
 
-  factory TestOutputImpl.fromCase (testCase, exitCode, timedOut, stdout, stderr, 
-    time) {
+  factory TestOutputImpl.fromCase (testCase, exitCode, timedOut,
+                                   stdout, stderr, time) {
     if (testCase is BrowserTestCase) {
       return new BrowserTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
     } else if (testCase.configuration['component'] == 'dartc') {
       return new AnalysisTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
     }
     return new TestOutputImpl(testCase, exitCode, timedOut,
       stdout, stderr, time);
   }
@@ skipping 22 matching lines @@
   bool get didFail() {
     return (exitCode != 0 && !hasCrashed);
   }
 
   // Reverse result of a negative test.
   bool get hasFailed() => (testCase.isNegative ? !didFail : didFail);
 
 }
 
 class BrowserTestOutputImpl extends TestOutputImpl {
-  BrowserTestOutputImpl(testCase, exitCode, timedOut, stdout, stderr, time) : 
+  BrowserTestOutputImpl(testCase, exitCode, timedOut, stdout, stderr, time) :
     super(testCase, exitCode, timedOut, stdout, stderr, time);
 
   bool get didFail() {
     // Browser case:
     // If the browser test failed, it may have been because DumpRenderTree
     // and the virtual framebuffer X server didn't hook up, or DRT crashed with
     // a core dump. Sometimes DRT crashes after it has set the stdout to PASS,
     // so we have to do this check first.
     for (String line in stderr) {
       if (line.contains('Gtk-WARNING **: cannot open display: :99') ||
@@ skipping 13 matching lines @@
     for (String line in stdout) {
       if (line == 'PASS' && previous_line == 'Content-Type: text/plain') {
         return (exitCode != 0 && !hasCrashed);
       }
       previous_line = line;
     }
     return true;
   }
 }
 
-// The static analyzer does not actaully execute code, so 
+// The static analyzer does not actaully execute code, so
 // the criteria for success now depend on the text sent
 // to stderr.
 class AnalysisTestOutputImpl extends TestOutputImpl {
-  boolean alreadyComputed = false;
-  boolean failResult;
-  AnalysisTestOutputImpl(testCase, exitCode, timedOut, stdout, stderr, time) : 
+  bool alreadyComputed = false;
+  bool failResult;
+  AnalysisTestOutputImpl(testCase, exitCode, timedOut, stdout, stderr, time) :
     super(testCase, exitCode, timedOut, stdout, stderr, time) {
   }
 
   bool get didFail() {
     if (!alreadyComputed) {
       failResult = _didFail();
       alreadyComputed = true;
     }
     return failResult;
   }
 
   bool _didFail() {
     if (hasCrashed) return false;
 
     List<String> errors = [];
     List<String> staticWarnings = [];
 
     // Read the returned list of errors and stuff them away.
     for (String line in stderr) {
       if (line.length == 0) continue;
       List<String> fields = splitMachineError(line);
       if (fields[0] == 'ERROR') {
         errors.add(fields);
       } else if (fields[0] == 'WARNING') {
         // We only care about testing Static type warnings
         // ignore all others
         if (fields[1] == 'STATIC_TYPE') {
           staticWarnings.add(fields);
-        } 
+        }
       }
       // OK to Skip error output that doesn't match the machine format
     }
-    if (testCase.info != null 
+    if (testCase.info != null
         && testCase.info.optionsFromFile['isMultitest']) {
       return _didMultitestFail(errors, staticWarnings);
     }
     return _didStandardTestFail(errors, staticWarnings);
   }
 
   bool _didMultitestFail(List errors, List staticWarnings) {
     String outcome = testCase.info.multitestOutcome;
     if ((outcome == '' || outcome == 'compile-time error') && errors.length > 0) {
       return true;
@@ skipping 41 matching lines @@
     if (numStaticTypeAnnotations > 0 && isStaticClean) {
       diagnostics.add("Cannot have both @static-clean and /// static type warning annotations.");
       return true;
     }
 
     if (isStaticClean && staticWarnings.length > 0) {
       diagnostics.add("@static-clean annotation found but analyzer returned warnings.");
       return true;
     }
 
-    if (numCompileTimeAnnotations > 0 
+    if (numCompileTimeAnnotations > 0
         && numCompileTimeAnnotations < errors.length) {
 
       // Expected compile-time errors were not returned.  The test did not 'fail' in the way
       // intended so don't return failed.
       diagnostics.add("Fewer compile time errors than annotated: ${numCompileTimeAnnotations}");
       return false;
     }
 
     if (numStaticTypeAnnotations > 0 || hasFatalTypeErrors) {
       // TODO(zundel): match up the annotation line numbers
       // with the reported error line numbers
       if (staticWarnings.length < numStaticTypeAnnotations) {
         diagnostics.add("Fewer static type warnings than annotated: ${numStaticTypeAnnotations}");
         return true;
       }
       return false;
     } else if (errors.length != 0) {
       return true;
-    } 
+    }
     return false;
   }
 
   // Parse a line delimited by the | character using \ as an escape charager
   // like:  FOO|BAR|FOO\|BAR|FOO\\BAZ as 4 fields: FOO BAR FOO|BAR FOO\BAZ
   List<String> splitMachineError(String line) {
     StringBuffer field = new StringBuffer();
     List<String> result = [];
     bool escaped = false;
     for (var i = 0 ; i < line.length; i++) {
@@ skipping 51 matching lines @@
   void testComplete(int exitCode) {
     new TestOutput.fromCase(testCase, exitCode, timedOut, stdout,
                             stderr, new Date.now().difference(startTime));
     timeoutTimer.cancel();
     if (testCase.output.unexpectedOutput && testCase.configuration['verbose']) {
       print(testCase.displayName);
       for (var line in testCase.output.stderr) print(line);
       for (var line in testCase.output.stdout) print(line);
     }
     if (allowRetries != null && allowRetries
-        && testCase.usesWebDriver && testCase.output.unexpectedOutput 
+        && testCase.usesWebDriver && testCase.output.unexpectedOutput
         && testCase.numRetries > 0) {
       // Selenium tests can be flaky. Try rerunning.
       testCase.output.requestRetry = true;
     }
     if (testCase.output.requestRetry) {
       testCase.output.requestRetry = false;
       this.timedOut = false;
       testCase.dynamic.numRetries--;
       print("Potential flake. Re-running ${testCase.displayName} " +
           "(${testCase.dynamic.numRetries} attempt(s) remains)");
@@ skipping 174 matching lines @@
     test.completed();
   }
 
   int _reportResult(String output) {
     _stdoutDrained = true;
     // output = '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
     var outcome = output.split(" ")[2];
     var exitCode = 0;
     if (outcome == "CRASH") exitCode = -10;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
-    new TestOutput.fromCase(_currentTest, exitCode, outcome == "TIMEOUT", 
+    new TestOutput.fromCase(_currentTest, exitCode, outcome == "TIMEOUT",
                    _testStdout, _testStderr, new Date.now().difference(_startTime));
     // Move on when both stdout and stderr has been drained. If the test
     // crashed, we restarted the process and therefore do not attempt to
     // drain stderr.
     if (_stderrDrained || (_currentTest.output.hasCrashed)) _testCompleted();
   }
 
   void _stderrDone() {
     _stderrDrained = true;
     // Move on when both stdout and stderr has been drained.
@@ skipping 261 matching lines @@
   }
 
   /**
    * True if we are using a browser + platform combination that needs the
    * Selenium server jar.
    */
   bool get _needsSelenium() => new Platform().operatingSystem() == 'macos' &&
       browserUsed == 'safari';
 
   /** True if the Selenium Server is ready to be used. */
-  bool get _isSeleniumAvailable() => _seleniumServer != null || 
+  bool get _isSeleniumAvailable() => _seleniumServer != null ||
       _seleniumAlreadyRunning;
 
   /**
-   * Restart all the processes that have been waiting/stopped for the server to 
+   * 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 (new Platform().operatingSystem() == 'windows') {
         cmd = 'tasklist';
         arg.add('/v');
       }
       Process p = new Process.start(cmd, arg);
-      final StringInputStream stdoutStringStream = 
+      final StringInputStream stdoutStringStream =
           new StringInputStream(p.stdout);
       stdoutStringStream.onLine = () {
         var line = stdoutStringStream.readLine();
         while (null != line) {
           if (const RegExp(@".*selenium-server-standalone.*").hasMatch(line)) {
             _seleniumAlreadyRunning = true;
             resumeTesting();
           }
           line = stdoutStringStream.readLine();
         }
@@ skipping 45 matching lines @@
     int index = filePath.lastIndexOf(pathSep);
     filePath = filePath.substring(0, index) + '${pathSep}testing${pathSep}';
     var dir = new Directory(filePath);
     dir.onFile = (String file) {
       if (const RegExp(@"selenium-server-standalone-.*\.jar").hasMatch(file)
           && _seleniumServer == null) {
         _seleniumServer = new Process.start('java', ['-jar', file]);
         // 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). 
+        // that is our condition for knowing that the server is ready).
         StringInputStream stdoutStringStream =
             new StringInputStream(_seleniumServer.stdout);
         StringInputStream stderrStringStream =
             new StringInputStream(_seleniumServer.stderr);
         stdoutStringStream.onLine =
             makeSeleniumServerHandler(stdoutStringStream);
         stderrStringStream.onLine =
             makeSeleniumServerHandler(stderrStringStream);
       }
     };
@@ skipping 65 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++;
     }
   }
 }