Remove uses of Selenium and webdriver from test scripts.

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;
 // 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 'dependency_graph.dart' as dgraph;
 import "browser_controller.dart";
 import "status_file_parser.dart";
 import "test_progress.dart";
 import "test_suite.dart";
 import "utils.dart";
 import 'record_and_replay.dart';
 
-const int CRASHING_BROWSER_EXITCODE = -10;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
 const MESSAGE_FAILED_TO_RUN_COMMAND = 'Failed to run command. return code=1';
 
 typedef void TestCaseEvent(TestCase testCase);
 typedef void ExitCodeEvent(int exitCode);
 typedef void EnqueueMoreWork(ProcessQueue queue);
 
 // Some IO tests use these variables and get confused if the host environment
@@ skipping 262 matching lines @@
   bool _equal(Command other) {
     return
         other is BrowserTestCommand &&
         super._equal(other) &&
         browser == other.browser &&
         url == other.url &&
         checkedMode == other.checkedMode;
   }
 }
 
-class SeleniumTestCommand extends Command {
-  final String browser;
-  final String url;
-
-  SeleniumTestCommand._(String _browser,
-                        this.url,
-                        String executable,
-                        List<String> arguments,
-                        String configurationDir)
-      : super._(_browser, executable, arguments, configurationDir),
-        browser = _browser;
-
-  void _buildHashCode(HashCodeBuilder builder) {
-    super._buildHashCode(builder);
-    builder.add(browser);
-    builder.add(url);
-  }
-
-  bool _equal(Command other) {
-    return
-        other is SeleniumTestCommand &&
-        super._equal(other) &&
-        browser == other.browser &&
-        url == other.url;
-  }
-}
-
 class AnalysisCommand extends Command {
   final String flavor;
 
   // If [fileFilter] is given, only errors/warnings reported by the analyzer
   // for which [fileFilter] returns [:true:] are considered.
   final Function fileFilter;
 
   AnalysisCommand._(this.flavor,
                     String displayName,
                     String executable,
@@ skipping 59 matching lines @@
                                            String executable,
                                            List<String> arguments,
                                            String configurationDir,
                                            {bool checkedMode: false}) {
     var command = new BrowserTestCommand._(
         browser, url, executable, arguments, configurationDir,
         checkedMode: checkedMode);
     return _getUniqueCommand(command);
   }
 
-  SeleniumTestCommand getSeleniumTestCommand(String browser,
-                                             String url,
-                                             String executable,
-                                             List<String> arguments,
-                                             String configurationDir) {
-    var command = new SeleniumTestCommand._(
-        browser, url, executable, arguments, configurationDir);
-    return _getUniqueCommand(command);
-  }
-
   CompilationCommand getCompilationCommand(String displayName,
                                            outputFile,
                                            neverSkipCompilation,
                                            List<String> bootstrapDependencies,
                                            String executable,
                                            List<String> arguments,
                                            String configurationDir) {
     var command =
         new CompilationCommand._(displayName, outputFile, neverSkipCompilation,
                                  bootstrapDependencies, executable, arguments,
@@ skipping 118 matching lines @@
     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 => commands.last.arguments;
 
-  bool get usesWebDriver => TestUtils.usesWebDriver(configuration['runtime']);
-
   bool get isFlaky {
       if (expectedOutcomes.contains(Expectation.SKIP) ||
           expectedOutcomes.contains(Expectation.SKIP_BY_DESIGN)) {
         return false;
       }
 
       return expectedOutcomes
         .where((expectation) => !expectation.isMetaExpectation).length > 1;
   }
 
@@ skipping 118 matching lines @@
   bool get hasCrashed {
     // The Java dartc runner and dart2js exits with code 253 in case
     // of unhandled exceptions.
     if (exitCode == 253) return true;
     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;
       }
-      // TODO(ricow): Remove this dirty hack ones we have a selenium
-      // replacement.
-      if (exitCode == CRASHING_BROWSER_EXITCODE) {
-        return !timedOut;
-      }
       // If a program receives an uncaught system exception, the program
       // terminates with the exception code as exit code.
       // The 0x3FFFFF00 mask here tries to determine if an exception indicates
       // a crash of the program.
       // System exception codes can be found in 'winnt.h', for example
       // "#define STATUS_ACCESS_VIOLATION  ((DWORD) 0xC0000005)"
       return (!timedOut && (exitCode < 0) && ((0x3FFFFF00 & exitCode) == 0));
     }
     return !timedOut && ((exitCode < 0));
   }
@@ skipping 439 matching lines @@
                                   Duration time,
                                   bool compilationSkipped) {
   if (command is ContentShellCommand) {
     return new BrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
   } else if (command is BrowserTestCommand) {
     return new HTMLBrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
-  } else if (command is SeleniumTestCommand) {
-    return new BrowserCommandOutputImpl(
-        command, exitCode, timedOut, stdout, stderr,
-        time, compilationSkipped);
   } else if (command is AnalysisCommand) {
     return new AnalysisCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
   } else if (command is VmCommand) {
     return new VmCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   } else if (command is CompilationCommand) {
     return new CompilationCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   } else if (command is JSCommandlineCommand) {
     return new JsCommandlineOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   }
 
   return new CommandOutputImpl(
       command, exitCode, timedOut, stdout, stderr,
       time, compilationSkipped);
 }
 
 
-/** Modifies the --timeout=XX parameter passed to run_selenium.py */
-List<String> _modifySeleniumTimeout(List<String> arguments, int timeout) {
-  return arguments.map((argument) {
-    if (argument.startsWith('--timeout=')) {
-      return "--timeout=$timeout";
-    } else {
-      return argument;
-    }
-  }).toList();
-}
-
-
 /**
  * A RunningProcess actually runs a test, getting the command lines from
  * 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.
  */
@@ skipping 17 matching lines @@
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
         var processEnvironment = _createProcessEnvironment();
-        var commandArguments = _modifySeleniumTimeout(command.arguments,
-                                                      timeout);
         Future processFuture =
             io.Process.start(command.executable,
-                             commandArguments,
+                             command.arguments,
                              environment: processEnvironment);
         processFuture.then((io.Process process) {
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
           void timeoutHandler() {
             timedOut = true;
             if (process != null) {
               process.kill();
             }
           }
@@ skipping 52 matching lines @@
     }
 
     return environment;
   }
 }
 
 class BatchRunnerProcess {
   static bool isWindows = io.Platform.operatingSystem == 'windows';
 
   final batchRunnerTypes = {
-      'selenium' : {
-          'run_executable' : 'python',
-          'run_arguments' : ['tools/testing/run_selenium.py', '--batch'],
-          'terminate_command' : ['--terminate'],
-      },
       'dartanalyzer' : {
         'run_executable' :
            isWindows ?
              'sdk\\bin\\dartanalyzer_developer.bat'
               : 'sdk/bin/dartanalyzer_developer',
         'run_arguments' : ['--batch'],
-        'terminate_command' : null,
       },
       'dart2analyzer' : {
         // This is a unix shell script, no windows equivalent available
         'run_executable' : 'editor/tools/analyzer',
         'run_arguments' : ['--batch'],
-        'terminate_command' : null,
     },
   };
 
   Completer<CommandOutput> _completer;
   Command _command;
   List<String> _arguments;
   String _runnerType;
 
   io.Process _process;
   Map _processEnvironmentOverrides;
@@ skipping 47 matching lines @@
   }
 
   Future terminate() {
     if (_process == null) return new Future.value(true);
     Completer terminateCompleter = new Completer();
     Timer killTimer;
     _processExitHandler = (_) {
       if (killTimer != null) killTimer.cancel();
       terminateCompleter.complete(true);
     };
-    var shutdownCommand = batchRunnerTypes[_runnerType]['terminate_command'];
-    if (shutdownCommand != null && !shutdownCommand.isEmpty) {
-      // Use a graceful shutdown so our Selenium script can close
-      // the open browser processes. On Windows, signals do not exist
-      // and a kill is a hard kill.
-      _process.stdin.writeln(shutdownCommand.join(' '));
-
-      // In case the run_selenium process didn't close, kill it after 30s
-      killTimer = new Timer(new Duration(seconds: 30), _process.kill);
-    } else {
-      _process.kill();
-    }
+    _process.kill();
 
     return terminateCompleter.future;
   }
 
   void doStartTest(Command command, int timeout) {
     _startTime = new DateTime.now();
     _testStdout = [];
     _testStderr = [];
     _status = null;
     _stdoutCompleter = new Completer();
     _stderrCompleter = new Completer();
     _timer = new Timer(new Duration(seconds: timeout),
                        _timeoutHandler);
 
     var line = _createArgumentsLine(_arguments, timeout);
     _process.stdin.write(line);
     _stdoutSubscription.resume();
     _stderrSubscription.resume();
     Future.wait([_stdoutCompleter.future,
                  _stderrCompleter.future]).then((_) => _reportResult());
   }
 
   String _createArgumentsLine(List<String> arguments, int timeout) {
-    arguments = _modifySeleniumTimeout(arguments, timeout);
     return arguments.join(' ') + '\n';
   }
 
   void _reportResult() {
     if (!_currentlyRunning) return;
     // _status == '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
 
     var outcome = _status.split(" ")[2];
     var exitCode = 0;
-    if (outcome == "CRASH") exitCode = CRASHING_BROWSER_EXITCODE;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
     var output = createCommandOutput(_command,
                         exitCode,
                         (outcome == "TIMEOUT"),
                         _testStdout,
                         _testStderr,
                         new DateTime.now().difference(_startTime),
                         false);
     assert(_completer != null);
     _completer.complete(output);
@@ skipping 298 matching lines @@
 
   Stream<CommandOutput> get completedCommands => _commandOutputStream.stream;
 
   Future get done => _completer.future;
 
   void _tryRunNextCommand() {
     _checkDone();
 
     if (_numProcesses < _maxProcesses && !_runQueue.isEmpty) {
       Command command = _runQueue.removeFirst();
-      var isBrowserCommand =
-          command is SeleniumTestCommand ||
-          command is BrowserTestCommand;
+      var isBrowserCommand = command is BrowserTestCommand;
 
       if (isBrowserCommand && _numBrowserProcesses == _maxBrowserProcesses) {
         // If there is no free browser runner, put it back into the queue.
         _runQueue.add(command);
         // Don't lose a process.
         new Timer(new Duration(milliseconds: 100), _tryRunNextCommand);
         return;
       }
 
       _numProcesses++;
@@ skipping 65 matching lines @@
   // TODO(kustermann): The [timeout] parameter should be a property of Command
   Future<CommandOutput> runCommand(
       dgraph.Node node, Command command, int timeout);
 }
 
 class CommandExecutorImpl implements CommandExecutor {
   final Map globalConfiguration;
   final int maxProcesses;
   final int maxBrowserProcesses;
 
-  // For dartc/selenium batch processing we keep a list of batch processes.
+  // For dartanalyzer batch processing we keep a list of batch processes.
   final _batchProcesses = new Map<String, List<BatchRunnerProcess>>();
   // We keep a BrowserTestRunner for every "browserName-checked" configuration.
   final _browserTestRunners = new Map<String, BrowserTestRunner>();
 
   bool _finishing = false;
 
   CommandExecutorImpl(
       this.globalConfiguration, this.maxProcesses, this.maxBrowserProcesses);
 
   Future cleanup() {
@@ skipping 32 matching lines @@
       });
     }
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
     var batchMode = !globalConfiguration['noBatch'];
 
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
-    } else if (command is SeleniumTestCommand && batchMode) {
-      var arguments = ['--force-refresh', '--browser=${command.browser}',
-                       '--timeout=${timeout}', '--out', '${command.url}'];
-      return _getBatchRunner(command.browser)
-          .runCommand('selenium', command, timeout, arguments);
     } else if (command is AnalysisCommand && batchMode) {
       return _getBatchRunner(command.flavor)
           .runCommand(command.flavor, command, timeout, command.arguments);
     } else {
       return new RunningProcess(command, timeout).run();
     }
   }
 
   BatchRunnerProcess _getBatchRunner(String identifier) {
     // Start batch processes if needed
@@ skipping 145 matching lines @@
       // "xvfb-run" issue 7564, try re-running the test.
       bool containsFailureMsg(String line) {
         return line.contains(MESSAGE_CANNOT_OPEN_DISPLAY) ||
                line.contains(MESSAGE_FAILED_TO_RUN_COMMAND);
       }
       if (stdout.any(containsFailureMsg) || stderr.any(containsFailureMsg)) {
         return true;
       }
     }
 
-    // Selenium tests can be flaky. Try re-running.
-    if (command is SeleniumTestCommand) {
-      return true;
-    }
-
     // We currently rerun dartium tests, see issue 14074
     if (command is BrowserTestCommand && command.displayName == 'dartium') {
       return true;
     }
   }
   return false;
 }
 
 /*
  * [TestCaseCompleter] will listen for
@@ skipping 213 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }