Refactor and clean up the status file parsing code.

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:async";
 import "dart:collection" show Queue;
 import "dart:convert" show LineSplitter, UTF8, JSON;
 // 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:math" as math;
 
 import 'android.dart';
 import "browser_controller.dart";
 import 'dependency_graph.dart' as dgraph;
+import "expectation.dart";
 import "path.dart";
 import 'record_and_replay.dart';
 import "runtime_configuration.dart";
-import "status_file_parser.dart";
 import "test_progress.dart";
 import "test_suite.dart";
 import "utils.dart";
 
 const int CRASHING_BROWSER_EXITCODE = -10;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 const int NON_UTF_FAKE_EXITCODE = 0xFFFD;
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
 const MESSAGE_FAILED_TO_RUN_COMMAND = 'Failed to run command. return code=1';
@@ skipping 450 matching lines @@
       if (exists) {
         cleanDirectoryFuture = TestUtils.deleteDirectory(_destinationDirectory);
       } else {
         cleanDirectoryFuture = new Future.value(null);
       }
       return cleanDirectoryFuture.then((_) {
         return TestUtils.copyDirectory(_sourceDirectory, _destinationDirectory);
       });
     }).then((_) {
       return new ScriptCommandOutputImpl(
-          this, Expectation.PASS, "", watch.elapsed);
+          this, Expectation.pass, "", watch.elapsed);
     }).catchError((error) {
       return new ScriptCommandOutputImpl(
-          this, Expectation.FAIL, "An error occured: $error.", watch.elapsed);
+          this, Expectation.fail, "An error occured: $error.", watch.elapsed);
     });
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(_sourceDirectory);
     builder.addJson(_destinationDirectory);
   }
 
   bool _equal(CleanDirectoryCopyCommand other) =>
@@ skipping 21 matching lines @@
       if (!targetExists) {
         throw new Exception("Target '$_target' does not exist");
       }
       var link = new io.Link(_link);
 
       return link.exists().then((bool exists) {
         if (exists) return link.delete();
       }).then((_) => link.create(_target));
     }).then((_) {
       return new ScriptCommandOutputImpl(
-          this, Expectation.PASS, "", watch.elapsed);
+          this, Expectation.pass, "", watch.elapsed);
     }).catchError((error) {
       return new ScriptCommandOutputImpl(
-          this, Expectation.FAIL, "An error occured: $error.", watch.elapsed);
+          this, Expectation.fail, "An error occured: $error.", watch.elapsed);
     });
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(_link);
     builder.addJson(_target);
   }
 
   bool _equal(MakeSymlinkCommand other) =>
@@ skipping 262 matching lines @@
   Command get lastCommandExecuted {
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
           "displayName: '$displayName', "
           "configurationString: '$configurationString')");
     }
     return commands[commandOutputs.length - 1];
   }
 
   int get timeout {
-    if (expectedOutcomes.contains(Expectation.SLOW)) {
+    if (expectedOutcomes.contains(Expectation.slow)) {
       return configuration['timeout'] * SLOW_TIMEOUT_MULTIPLIER;
     } else {
       return configuration['timeout'];
     }
   }
 
   String get configurationString {
     final compiler = configuration['compiler'];
     final runtime = configuration['runtime'];
     final mode = configuration['mode'];
     final arch = configuration['arch'];
     final checked = configuration['checked'] ? '-checked' : '';
     return "$compiler-$runtime$checked ${mode}_$arch";
   }
 
   List<String> get batchTestArguments {
     assert(commands.last is ProcessCommand);
     return (commands.last as ProcessCommand).arguments;
   }
 
   bool get isFlaky {
-    if (expectedOutcomes.contains(Expectation.SKIP) ||
-        expectedOutcomes.contains(Expectation.SKIP_BY_DESIGN)) {
+    if (expectedOutcomes.contains(Expectation.skip) ||
+        expectedOutcomes.contains(Expectation.skipByDesign)) {
       return false;
     }
 
     return expectedOutcomes
-            .where((expectation) => !expectation.isMetaExpectation)
+            .where((expectation) => expectation.isOutcome)
             .length >
         1;
   }
 
   bool get isFinished {
     return commandOutputs.length > 0 &&
         (!lastCommandOutput.successful ||
             commands.length == commandOutputs.length);
   }
 }
@@ skipping 27 matching lines @@
 
   bool _isAsyncTestSuccessful(String testOutput) {
     return testOutput.contains("unittest-suite-success");
   }
 
   Expectation _negateOutcomeIfIncompleteAsyncTest(
       Expectation outcome, String testOutput) {
     // If this is an asynchronous test and the asynchronous operation didn't
     // complete successfully, it's outcome is Expectation.FAIL.
     // TODO: maybe we should introduce a AsyncIncomplete marker or so
-    if (outcome == Expectation.PASS) {
+    if (outcome == Expectation.pass) {
       if (_isAsyncTest(testOutput) && !_isAsyncTestSuccessful(testOutput)) {
-        return Expectation.FAIL;
+        return Expectation.fail;
       }
     }
     return outcome;
   }
 }
 
 /**
  * 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 does not contain a pointer to the
@@ skipping 56 matching lines @@
       bool this.timedOut,
       List<int> this.stdout,
       List<int> this.stderr,
       Duration this.time,
       bool this.compilationSkipped,
       int this.pid) {
     diagnostics = [];
   }
 
   Expectation result(TestCase testCase) {
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasFailed(testCase)) return Expectation.FAIL;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
-    return Expectation.PASS;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasFailed(testCase)) return Expectation.fail;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
+    return Expectation.pass;
   }
 
   bool get hasCrashed {
     // dart2js exits with code 253 in case of unhandled exceptions.
     // The dart binary exits with code 253 in case of an API error such
     // as an invalid snapshot file.
     // In either case an exit code of 253 is considered a crash.
     if (exitCode == 253) return true;
     if (io.Platform.operatingSystem == 'windows') {
       // The VM uses std::abort to terminate on asserts.
@@ skipping 31 matching lines @@
   // Reverse result of a negative test.
   bool hasFailed(TestCase testCase) {
     return testCase.isNegative ? !didFail(testCase) : didFail(testCase);
   }
 
   bool get hasNonUtf8 => exitCode == NON_UTF_FAKE_EXITCODE;
 
   Expectation _negateOutcomeIfNegativeTest(
       Expectation outcome, bool isNegative) {
     if (!isNegative) return outcome;
-    if (outcome == Expectation.IGNORE) return outcome;
-    if (outcome.canBeOutcomeOf(Expectation.FAIL)) {
-      return Expectation.PASS;
+    if (outcome == Expectation.ignore) return outcome;
+    if (outcome.canBeOutcomeOf(Expectation.fail)) {
+      return Expectation.pass;
     }
-    return Expectation.FAIL;
+    return Expectation.fail;
   }
 }
 
 class BrowserCommandOutputImpl extends CommandOutputImpl {
   // Although tests are reported as passing, content shell sometimes exits with
   // a nonzero exitcode which makes our dartium builders extremely falky.
   // See: http://dartbug.com/15139.
+  // TODO(rnystrom): Is this still needed? The underlying bug is closed.
   static int WHITELISTED_CONTENTSHELL_EXITCODE = -1073740022;
   static bool isWindows = io.Platform.operatingSystem == 'windows';
   static bool _failedBecauseOfFlakyInfrastructure(
       Command command, bool timedOut, List<int> stderrBytes) {
     // If the browser test failed, it may have been because content shell
     // and the virtual framebuffer X server didn't hook up, or it crashed with
     // a core dump. Sometimes content shell crashes after it has set the stdout
     // to PASS, so we have to do this check first.
     // Content shell also fails with a broken pipe message: Issue 26739
     var zygoteCrash =
@@ skipping 33 matching lines @@
       List<int> stderr,
       Duration time,
       bool compilationSkipped)
       : _infraFailure =
             _failedBecauseOfFlakyInfrastructure(command, timedOut, stderr),
         super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     if (_infraFailure) {
-      return Expectation.IGNORE;
+      return Expectation.ignore;
     }
+
     // Handle crashes and timeouts first
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     var outcome = _getOutcome();
 
     if (testCase.hasRuntimeError) {
-      if (!outcome.canBeOutcomeOf(Expectation.RUNTIME_ERROR)) {
-        return Expectation.MISSING_RUNTIME_ERROR;
+      if (!outcome.canBeOutcomeOf(Expectation.runtimeError)) {
+        return Expectation.missingRuntimeError;
       }
     }
     if (testCase.isNegative) {
-      if (outcome.canBeOutcomeOf(Expectation.FAIL)) return Expectation.PASS;
-      return Expectation.FAIL;
+      if (outcome.canBeOutcomeOf(Expectation.fail)) return Expectation.pass;
+      return Expectation.fail;
     }
     return outcome;
   }
 
   bool get successful => canRunDependendCommands;
 
   bool get canRunDependendCommands {
     // We cannot rely on the exit code of content_shell as a method to
     // determine if we were successful or not.
     return super.canRunDependendCommands && !didFail(null);
   }
 
   bool get hasCrashed {
     return super.hasCrashed || _rendererCrashed;
   }
 
   Expectation _getOutcome() {
     if (_browserTestFailure) {
-      return Expectation.RUNTIME_ERROR;
+      return Expectation.runtimeError;
     }
-    return Expectation.PASS;
+    return Expectation.pass;
   }
 
   bool get _rendererCrashed =>
       decodeUtf8(super.stdout).contains("#CRASHED - rendere");
 
   bool get _browserTestFailure {
     // Browser tests fail unless stdout contains
     // 'Content-Type: text/plain' followed by 'PASS'.
     bool hasContentType = false;
     var stdoutLines = decodeUtf8(super.stdout).split("\n");
@@ skipping 52 matching lines @@
       int exitCode,
       bool timedOut,
       List<int> stdout,
       List<int> stderr,
       Duration time,
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped);
 
   bool didFail(TestCase testCase) {
-    return _getOutcome() != Expectation.PASS;
+    return _getOutcome() != Expectation.pass;
   }
 
   bool get _browserTestFailure {
     // We should not need to convert back and forward.
     var output = decodeUtf8(super.stdout);
     if (output.contains("FAIL")) return true;
     return !output.contains("PASS");
   }
 }
 
@@ skipping 70 matching lines @@
   static Expectation _getOutcome(Map<String, List<String>> messagesByType) {
     occured(String type) => messagesByType[type].length > 0;
     searchForMsg(List<String> types, String message) {
       return types.any((type) => messagesByType[type].contains(message));
     }
 
     // FIXME(kustermann,ricow): I think this functionality doesn't work in
     // test_controller.js: So far I haven't seen anything being reported on
     // "window.compilationerror"
     if (occured('window_compilationerror')) {
-      return Expectation.COMPILETIME_ERROR;
+      return Expectation.compileTimeError;
     }
 
     if (occured('sync_exception') ||
         occured('window_onerror') ||
         occured('script_onerror')) {
-      return Expectation.RUNTIME_ERROR;
+      return Expectation.runtimeError;
     }
 
     if (messagesByType['dom'][0].contains('FAIL')) {
-      return Expectation.RUNTIME_ERROR;
+      return Expectation.runtimeError;
     }
 
     // We search for these messages in 'print' and 'message_received' because
     // the unittest implementation posts these messages using
     // "window.postMessage()" instead of the normal "print()" them.
 
     var isAsyncTest = searchForMsg(
         ['print', 'message_received'], 'unittest-suite-wait-for-done');
     var isAsyncSuccess =
         searchForMsg(['print', 'message_received'], 'unittest-suite-success') ||
             searchForMsg(['print', 'message_received'], 'unittest-suite-done');
 
     if (isAsyncTest) {
       if (isAsyncSuccess) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.RUNTIME_ERROR;
+      return Expectation.runtimeError;
     }
 
     var mainStarted =
         searchForMsg(['print', 'message_received'], 'dart-calling-main');
     var mainDone =
         searchForMsg(['print', 'message_received'], 'dart-main-done');
 
     if (mainStarted && mainDone) {
-      return Expectation.PASS;
+      return Expectation.pass;
     }
-    return Expectation.FAIL;
+    return Expectation.fail;
   }
 }
 
 class BrowserControllerTestOutcome extends CommandOutputImpl
     with UnittestSuiteMessagesMixin {
   BrowserTestOutput _result;
   Expectation _rawOutcome;
 
   factory BrowserControllerTestOutcome(
       Command command, BrowserTestOutput result) {
@@ skipping 10 matching lines @@
     String stderr = "";
     Expectation outcome;
 
     var parsedResult =
         BrowserTestJsonResult.parseFromString(result.lastKnownMessage);
     if (parsedResult != null) {
       outcome = parsedResult.outcome;
     } else {
       // Old way of determining whether a test failed or passed.
       if (result.lastKnownMessage.contains("FAIL")) {
-        outcome = Expectation.RUNTIME_ERROR;
+        outcome = Expectation.runtimeError;
       } else if (result.lastKnownMessage.contains("PASS")) {
-        outcome = Expectation.PASS;
+        outcome = Expectation.pass;
       } else {
-        outcome = Expectation.RUNTIME_ERROR;
+        outcome = Expectation.runtimeError;
       }
     }
 
     if (result.didTimeout) {
       if (result.delayUntilTestStarted != null) {
         stderr = "This test timed out. The delay until the test actually "
             "started was: ${result.delayUntilTestStarted}.";
       } else {
         stderr = "This test has not notified test.py that it started running.";
       }
@@ skipping 22 matching lines @@
       this._rawOutcome,
       List<int> stdout,
       List<int> stderr)
       : super(command, 0, result.didTimeout, stdout, stderr, result.duration,
             false, 0) {
     _result = result;
   }
 
   Expectation result(TestCase testCase) {
     // Handle timeouts first
-    if (_result.didTimeout) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (_result.didTimeout) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     // Multitests are handled specially
     if (testCase.hasRuntimeError) {
-      if (_rawOutcome == Expectation.RUNTIME_ERROR) return Expectation.PASS;
-      return Expectation.MISSING_RUNTIME_ERROR;
+      if (_rawOutcome == Expectation.runtimeError) return Expectation.pass;
+      return Expectation.missingRuntimeError;
     }
 
     return _negateOutcomeIfNegativeTest(_rawOutcome, testCase.isNegative);
   }
 }
 
 class AnalysisCommandOutputImpl extends CommandOutputImpl {
   // An error line has 8 fields that look like:
   // ERROR|COMPILER|MISSING_SOURCE|file:/tmp/t.dart|15|1|24|Missing source.
   final int ERROR_LEVEL = 0;
@@ skipping 11 matching lines @@
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // TODO(kustermann): If we run the analyzer not in batch mode, make sure
     // that command.exitCodes matches 2 (errors), 1 (warnings), 0 (no warnings,
     // no errors)
 
     // Handle crashes and timeouts first
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     // Get the errors/warnings from the analyzer
     List<String> errors = [];
     List<String> warnings = [];
     parseAnalyzerOutput(errors, warnings);
 
     // Handle errors / missing errors
     if (testCase.expectCompileError) {
       if (errors.length > 0) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.MISSING_COMPILETIME_ERROR;
+      return Expectation.missingCompileTimeError;
     }
     if (errors.length > 0) {
-      return Expectation.COMPILETIME_ERROR;
+      return Expectation.compileTimeError;
     }
 
     // Handle static warnings / missing static warnings
     if (testCase.hasStaticWarning) {
       if (warnings.length > 0) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.MISSING_STATIC_WARNING;
+      return Expectation.missingStaticWarning;
     }
     if (warnings.length > 0) {
-      return Expectation.STATIC_WARNING;
+      return Expectation.staticWarning;
     }
 
     assert(errors.length == 0 && warnings.length == 0);
     assert(!testCase.hasCompileError && !testCase.hasStaticWarning);
-    return Expectation.PASS;
+    return Expectation.pass;
   }
 
   void parseAnalyzerOutput(List<String> outErrors, List<String> outWarnings) {
     // Parse a line delimited by the | character using \ as an escape character
     // 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 35 matching lines @@
   static const DART_VM_EXITCODE_DFE_ERROR = 252;
   static const DART_VM_EXITCODE_COMPILE_TIME_ERROR = 254;
   static const DART_VM_EXITCODE_UNCAUGHT_EXCEPTION = 255;
 
   VmCommandOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time, int pid)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, pid);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
-    if (exitCode == DART_VM_EXITCODE_DFE_ERROR) return Expectation.DARTK_CRASH;
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (exitCode == DART_VM_EXITCODE_DFE_ERROR) return Expectation.dartkCrash;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     // Multitests are handled specially
     if (testCase.expectCompileError) {
       if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.MISSING_COMPILETIME_ERROR;
+      return Expectation.missingCompileTimeError;
     }
     if (testCase.hasRuntimeError) {
       // TODO(kustermann): Do we consider a "runtimeError" only an uncaught
       // exception or does any nonzero exit code fullfil this requirement?
       if (exitCode != 0) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.MISSING_RUNTIME_ERROR;
+      return Expectation.missingRuntimeError;
     }
 
     // The actual outcome depends on the exitCode
     Expectation outcome;
     if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
-      outcome = Expectation.COMPILETIME_ERROR;
+      outcome = Expectation.compileTimeError;
     } else if (exitCode == DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
-      outcome = Expectation.RUNTIME_ERROR;
+      outcome = Expectation.runtimeError;
     } else if (exitCode != 0) {
       // This is a general fail, in case we get an unknown nonzero exitcode.
-      outcome = Expectation.FAIL;
+      outcome = Expectation.fail;
     } else {
-      outcome = Expectation.PASS;
+      outcome = Expectation.pass;
     }
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class CompilationCommandOutputImpl extends CommandOutputImpl {
   static const DART2JS_EXITCODE_CRASH = 253;
 
   CompilationCommandOutputImpl(
       Command command,
       int exitCode,
       bool timedOut,
       List<int> stdout,
       List<int> stderr,
       Duration time,
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // Handle general crash/timeout detection.
-    if (hasCrashed) return Expectation.CRASH;
+    if (hasCrashed) return Expectation.crash;
     if (hasTimedOut) {
       bool isWindows = io.Platform.operatingSystem == 'windows';
       bool isBrowserTestCase =
           testCase.commands.any((command) => command is BrowserTestCommand);
       // TODO(26060) Dart2js batch mode hangs on Windows under heavy load.
       return (isWindows && isBrowserTestCase)
-          ? Expectation.IGNORE
-          : Expectation.TIMEOUT;
+          ? Expectation.ignore
+          : Expectation.timeout;
     }
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     // Handle dart2js specific crash detection
     if (exitCode == DART2JS_EXITCODE_CRASH ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_COMPILE_TIME_ERROR ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
-      return Expectation.CRASH;
+      return Expectation.crash;
     }
 
     // Multitests are handled specially
     if (testCase.expectCompileError) {
       // Nonzero exit code of the compiler means compilation failed
       // TODO(kustermann): Do we have a special exit code in that case???
       if (exitCode != 0) {
-        return Expectation.PASS;
+        return Expectation.pass;
       }
-      return Expectation.MISSING_COMPILETIME_ERROR;
+      return Expectation.missingCompileTimeError;
     }
 
     // TODO(kustermann): This is a hack, remove it
     if (testCase.hasRuntimeError && testCase.commands.length > 1) {
       // We expected to run the test, but we got an compile time error.
       // If the compilation succeeded, we wouldn't be in here!
       assert(exitCode != 0);
-      return Expectation.COMPILETIME_ERROR;
+      return Expectation.compileTimeError;
     }
 
     Expectation outcome =
-        exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
+        exitCode == 0 ? Expectation.pass : Expectation.compileTimeError;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class KernelCompilationCommandOutputImpl extends CompilationCommandOutputImpl {
   KernelCompilationCommandOutputImpl(
       Command command,
       int exitCode,
       bool timedOut,
       List<int> stdout,
       List<int> stderr,
       Duration time,
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
             compilationSkipped);
 
   bool get canRunDependendCommands {
     // See [BatchRunnerProcess]: 0 means success, 1 means compile-time error.
     // TODO(asgerf): When the frontend supports it, continue running even if
     //   there were compile-time errors. See kernel_sdk issue #18.
     return !hasCrashed && !timedOut && exitCode == 0;
   }
 
   Expectation result(TestCase testCase) {
     Expectation result = super.result(testCase);
-    if (result.canBeOutcomeOf(Expectation.CRASH)) {
-      return Expectation.DARTK_CRASH;
-    } else if (result.canBeOutcomeOf(Expectation.TIMEOUT)) {
-      return Expectation.DARTK_TIMEOUT;
-    } else if (result.canBeOutcomeOf(Expectation.COMPILETIME_ERROR)) {
-      return Expectation.DARTK_COMPILETIME_ERROR;
+    if (result.canBeOutcomeOf(Expectation.crash)) {
+      return Expectation.dartkCrash;
+    } else if (result.canBeOutcomeOf(Expectation.timeout)) {
+      return Expectation.dartkTimeout;
+    } else if (result.canBeOutcomeOf(Expectation.compileTimeError)) {
+      return Expectation.dartkCompileTimeError;
     }
     return result;
   }
 
   // If the compiler was able to produce a Kernel IR file we want to run the
   // result on the Dart VM.  We therefore mark the [KernelCompilationCommand] as
   // successful.
   // => This ensures we test that the DartVM produces correct CompileTime errors
   //    as it is supposed to for our test suites.
   bool get successful => canRunDependendCommands;
 }
 
 class JsCommandlineOutputImpl extends CommandOutputImpl
     with UnittestSuiteMessagesMixin {
   JsCommandlineOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     if (testCase.hasRuntimeError) {
-      if (exitCode != 0) return Expectation.PASS;
-      return Expectation.MISSING_RUNTIME_ERROR;
+      if (exitCode != 0) return Expectation.pass;
+      return Expectation.missingRuntimeError;
     }
 
-    var outcome = exitCode == 0 ? Expectation.PASS : Expectation.RUNTIME_ERROR;
+    var outcome = exitCode == 0 ? Expectation.pass : Expectation.runtimeError;
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class PubCommandOutputImpl extends CommandOutputImpl {
   PubCommandOutputImpl(PubCommand command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
-    if (hasCrashed) return Expectation.CRASH;
-    if (hasTimedOut) return Expectation.TIMEOUT;
-    if (hasNonUtf8) return Expectation.NON_UTF8_ERROR;
+    if (hasCrashed) return Expectation.crash;
+    if (hasTimedOut) return Expectation.timeout;
+    if (hasNonUtf8) return Expectation.nonUtf8Error;
 
     if (exitCode == 0) {
-      return Expectation.PASS;
+      return Expectation.pass;
     } else if ((command as PubCommand).command == 'get') {
-      return Expectation.PUB_GET_ERROR;
+      return Expectation.pubGetError;
     } else {
-      return Expectation.FAIL;
+      return Expectation.fail;
     }
   }
 }
 
 class ScriptCommandOutputImpl extends CommandOutputImpl {
   final Expectation _result;
 
   ScriptCommandOutputImpl(ScriptCommand command, this._result,
       String scriptExecutionInformation, Duration time)
       : super(command, 0, false, [], [], time, false, 0) {
     var lines = scriptExecutionInformation.split("\n");
     diagnostics.addAll(lines);
   }
 
   Expectation result(TestCase testCase) => _result;
 
-  bool get canRunDependendCommands => _result == Expectation.PASS;
+  bool get canRunDependendCommands => _result == Expectation.pass;
 
-  bool get successful => _result == Expectation.PASS;
+  bool get successful => _result == Expectation.pass;
 }
 
 CommandOutput createCommandOutput(Command command, int exitCode, bool timedOut,
     List<int> stdout, List<int> stderr, Duration time, bool compilationSkipped,
     [int pid = 0]) {
   if (command is ContentShellCommand) {
     return new BrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is BrowserTestCommand) {
     return new HTMLBrowserCommandOutputImpl(
@@ skipping 1534 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }