Working SimpleHTML test front end

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 272 matching lines @@
 
   String get reproductionCommand {
     var parts = [TestUtils.dartTestExecutable.toString(),
                 'tools/testing/dart/launch_browser.dart',
                 browser,
                 url];
     return parts.map(escapeCommandLineArgument).join(' ');
   }
 }
 
+class BrowserHtmlTestCommand extends BrowserTestCommand {
+  List<String> expectedMessages;
+  BrowserHtmlTestCommand._(String browser,
+                           String url,
+                           Map configuration,
+                           this.expectedMessages)
+      : super._(browser, url, configuration);
+
+  void _buildHashCode(HashCodeBuilder builder) {
+    super._buildHashCode(builder);
+    builder.addJson(expectedMessages);
+  }
+
+  bool _equal(BrowserHtmlTestCommand other) =>
+      super._equal(other) &&
+      identical(expectedMessages, other.expectedMessages);
+}
+
 class AnalysisCommand extends ProcessCommand {
   final String flavor;
 
   AnalysisCommand._(this.flavor,
                     String displayName,
                     String executable,
                     List<String> arguments,
                     Map<String, String> environmentOverrides)
       : super._(displayName, executable, arguments, environmentOverrides);
 
@@ skipping 243 matching lines @@
     return _getUniqueCommand(command);
   }
 
   BrowserTestCommand getBrowserTestCommand(String browser,
                                            String url,
                                            Map configuration) {
     var command = new BrowserTestCommand._(browser, url, configuration);
     return _getUniqueCommand(command);
   }
 
+  BrowserHtmlTestCommand getBrowserHtmlTestCommand(String browser,
+                                               String url,
+                                               Map configuration,
+                                               List<String> expectedMessages) {
+    var command = new BrowserHtmlTestCommand._(
+        browser, url, configuration, expectedMessages);
+    return _getUniqueCommand(command);
+  }
+
   CompilationCommand getCompilationCommand(String displayName,
                                            outputFile,
                                            neverSkipCompilation,
                                            List<Uri> bootstrapDependencies,
                                            String executable,
                                            List<String> arguments,
                                            Map<String, String> environment) {
     var command =
         new CompilationCommand._(
             displayName, outputFile, neverSkipCompilation,
@@ skipping 1773 matching lines @@
         _commandOutputStream.add(output);
         if (output.canRunDependendCommands) {
           graph.changeState(node, dgraph.NodeState.Successful);
         } else {
           graph.changeState(node, dgraph.NodeState.Failed);
         }
 
         _numProcesses--;
         if (isBrowserCommand) _numBrowserProcesses--;
 
-        // Don't loose a process
+        // Don't lose a process
         Timer.run(() => _tryRunNextCommand());
       });
     }
   }
 
   void _checkDone() {
     if (!_finishing &&
         _runQueue.isEmpty &&
         _numProcesses == 0 &&
         graph.isSealed &&
@@ skipping 132 matching lines @@
   }
 
   Future<CommandOutput> _startBrowserControllerTest(
       BrowserTestCommand browserCommand, int timeout) {
     var completer = new Completer<CommandOutput>();
 
     var callback = (BrowserTestOutput output) {
       completer.complete(
           new BrowserControllerTestOutcome(browserCommand, output));
     };
-    BrowserTest browserTest = new BrowserTest(browserCommand.url,
-                                              callback,
-                                              timeout);
+
+    BrowserTest browserTest;
+    if (browserCommand is BrowserHtmlTestCommand) {
+      browserTest = new HtmlTest(browserCommand.url, callback, timeout,
+          browserCommand.expectedMessages);
+    } else {
+      browserTest = new BrowserTest(browserCommand.url, callback, timeout);
+    }
     _getBrowserTestRunner(browserCommand.browser, browserCommand.configuration)
         .then((testRunner) {
       testRunner.queueTest(browserTest);
     });
 
     return completer.future;
   }
 
   Future<BrowserTestRunner> _getBrowserTestRunner(String browser,
                                                   Map configuration) {
@@ skipping 393 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }