Adjust test logging output so what we can separate logging failure explanations from actual test fa…

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 63 matching lines @@
 }
 
 
 /** A command executed as a step in a test case. */
 class Command {
   /** Path to the executable of this command. */
   String executable;
 
   /** 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') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
@@ skipping 99 matching lines @@
     }
 
     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;
   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
  * contains static information about the test; actually running the test is
  * performed by [ProcessQueue] using a [RunningProcess] object.
  *
  * The output information is stored in a [CommandOutput] instance contained
  * in TestCase.commandOutputs. The last CommandOutput instance is responsible
  * for evaluating if the test has passed, failed, crashed, or timed out, and the
  * TestCase has information about what the expected result of the test should
  * be.
  *
  * The TestCase has a callback function, [completedHandler], that is run when
  * the test is completed.
  */
 class TestCase {
   /**
-   * A list of commands to execute. Most test cases have a single command. 
+   * A list of commands to execute. Most test cases have a single command.
    * Dart2js tests have two commands, one to compile the source and another
    * to execute it. Some isolate tests might even have three, if they require
    * compiling multiple sources that are run in isolation.
    */
   List<Command> commands;
   Map<Command, CommandOutput> commandOutputs = new Map<Command,CommandOutput>();
 
   Map configuration;
   String displayName;
   bool isNegative;
@@ skipping 121 matching lines @@
    * flaky browser tests.
    */
   int numRetries;
 
   /**
    * True if this test is dependent on another test completing before it can
    * star (for example, we might need to depend on some other test completing
    * first).
    */
   bool waitingForOtherTest;
-  
+
   /**
    * The set of test cases that wish to be notified when this test has
    * completed.
    */
   List<BrowserTestCase> observers;
 
   BrowserTestCase(displayName, commands, configuration, completedHandler,
       expectedOutcomes, info, isNegative, [this.waitingForOtherTest = false])
     : super(displayName, commands, configuration, completedHandler,
         expectedOutcomes, isNegative: isNegative, info: info) {
@@ skipping 19 matching lines @@
    */
   void notifyObservers() {
     for (BrowserTestCase testCase in observers) {
       testCase.waitingForOtherTest = false;
     }
   }
 }
 
 
 /**
- * CommandOutput records the output of a completed command: the process's exit 
+ * CommandOutput records the output of a completed command: 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.
  */
 abstract class CommandOutput {
   factory CommandOutput.fromCase(TestCase testCase,
                                  Command command,
                                  int exitCode,
                                  bool incomplete,
                                  bool timedOut,
@@ skipping 201 matching lines @@
     // so we have to do this check first.
     var stderrLines = new String.fromCharCodes(super.stderr).split("\n");
     for (String line in stderrLines) {
       if (line.contains('Gtk-WARNING **: cannot open display: :99') ||
           line.contains('Failed to run command. return code=1')) {
         // If we get the X server error, or DRT crashes with a core dump, retry
         // the test.
         if ((testCase as BrowserTestCase).numRetries > 0) {
           requestRetry = true;
         }
-        printDebug("Failed because of missing XDisplay");
+        printDebug("Test failure because of missing XDisplay");
         return true;
       }
     }
     return false;
   }
 
   bool get _failedBecauseOfUnexpectedDRTOutput {
     /*
      * The output of DumpRenderTree is different for pixel tests than for
      * layout tests.
@@ skipping 28 matching lines @@
             var startPosition = newLineAfterContentLength +
                 bytesNewLine.length;
             var endPosition = stdout.length - bytesEOF.length;
 
             var _failed = !areByteArraysEqual(expectedContent,
                                               0,
                                               stdout,
                                               startPosition,
                                               endPosition - startPosition);
             if (_failed) {
-              printDebug("Failed because command.expectedOutputFile doesn't "
-                         "match stdout of DRT");
+              printDebug("Test failure because command.expectedOutputFile "
+                         "doesn't match stdout of DRT");
             }
             return _failed;
           }
         }
-        printDebug("Failed because we didn't find 'Content-Length' in the DRT "
-                   "output");
+        printDebug("Test failure because we didn't find 'Content-Length' in the"
+                   " DRT output");
         return true;
       } else {
         var _failed = !areByteArraysEqual(expectedContent, 0,
                                           stdout, 0,
                                           stdout.length);
         if (_failed) {
-          printDebug("Failed because command.expectedOutputFile doesn't match "
-                     "stdout of DRT");
+          printDebug("Test failure because command.expectedOutputFile doesn't "
+                     "match stdout of DRT");
         }
         return _failed;
       }
     }
-    printDebug("Failed because command.expectedOutputFile doesn't exist");
+    printDebug("Test failure because command.expectedOutputFile doesn't exist");
     return true;
   }
 
   bool get _browserTestFailure {
     // Browser tests fail unless stdout contains
     // 'Content-Type: text/plain' followed by 'PASS'.
     bool has_content_type = false;
     var stdoutLines = new String.fromCharCodes(super.stdout).split("\n");
     for (String line in stdoutLines) {
       switch (line) {
         case 'Content-Type: text/plain':
           has_content_type = true;
           break;
         case 'PASS':
           if (has_content_type) {
             var _failed = (exitCode != 0 && !hasCrashed);
             if (_failed) {
-              printDebug("Failed because '(exitCode != 0 && !hasCrashed) was "
-                         "true");
+              printDebug("Test failure because '(exitCode != 0 && !hasCrashed) "
+                         "was true");
             }
             return _failed;
           }
           break;
       }
     }
-    printDebug("Failed because content-type: text/plain + PASS was not found");
+    printDebug("Test failure because content-type: text/plain + PASS was not "
+               "found");
     return true;
   }
 
   void printDebug(String msg) {
     print("");
     print("DEBUG(infrastructure): $msg");
     print("DEBUG(infrastructure): cmd.executable:  '${command.executable}'");
     print("DEBUG(infrastructure): cmd.arguments:   '${command.arguments}'");
     print("DEBUG(infrastructure): cmd.environment: '${command.environment}'");
     print("");
@@ skipping 1014 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++;
     }
   }
 }