Remove deprecated Expect from the libraries.

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 257 matching lines @@
     // replace '@' with the original command executable, and generate
     // a command formed like the following
     // Let PREFIX be what is before the @.
     // Let SUFFIX be what is after the @.
     // Let EXECUTABLE be the existing executable of the command.
     // Let ARGUMENTS be the existing arguments to the existing executable.
     // The new command will be:
     // PREFIX EXECUTABLE SUFFIX ARGUMENTS
     var specialCommand = configuration['special-command'];
     if (!specialCommand.isEmpty) {
-      Expect.isTrue(specialCommand.contains('@'),
-                    "special-command must contain a '@' char");
+      if (!specialCommand.contains('@')) {
+        throw new Exception("special-command must contain a '@' char");
+      }
       var specialCommandSplit = specialCommand.split('@');
       var prefix = specialCommandSplit[0].trim();
       var suffix = specialCommandSplit[1].trim();
       List<Command> newCommands = [];
       for (Command c in commands) {
         // If we don't have a new prefix we will use the existing executable.
         var newExecutablePath = c.executable;;
         var newArguments = [];
 
         if (prefix.length > 0) {
@@ skipping 513 matching lines @@
     }
     if (testCase.info != null
         && testCase.info.optionsFromFile['isMultitest']) {
       return _didMultitestFail(errors, staticWarnings);
     }
     return _didStandardTestFail(errors, staticWarnings);
   }
 
   bool _didMultitestFail(List errors, List staticWarnings) {
     Set<String> outcome = testCase.info.multitestOutcome;
-    Expect.isNotNull(outcome);
+    if (outcome == null) throw new Exception("outcome must not be null");
     if (outcome.contains('compile-time error') && errors.length > 0) {
       return true;
     } else if (outcome.contains('static type warning')
         && staticWarnings.length > 0) {
       return true;
     } else if (outcome.isEmpty
         && (errors.length > 0 || staticWarnings.length > 0)) {
       return true;
     }
     return false;
@@ skipping 112 matching lines @@
   DateTime startTime;
   Timer timeoutTimer;
   List<int> stdout = <int>[];
   List<int> stderr = <int>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
 
   RunningProcess(TestCase this.testCase, Command this.command);
 
   Future<CommandOutput> start() {
-    Expect.isFalse(testCase.expectedOutcomes.contains(SKIP));
+    if (testCase.expectedOutcomes.contains(SKIP)) {
+      throw new Exception("testCase.expectedOutcomes must not contain 'SKIP'.");
+    }
 
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
     _runCommand();
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
@@ skipping 91 matching lines @@
   BatchRunnerProcess(TestCase testCase) {
     _command = testCase.commands.last;
     _executable = testCase.commands.last.executable;
     _batchArguments = testCase.batchRunnerArguments;
     _isWebDriver = testCase.usesWebDriver;
   }
 
   bool get active => _currentTest != null;
 
   void startTest(TestCase testCase) {
-    Expect.isNull(_currentTest);
+    if (_currentTest != null) {
+      throw new Exception("_currentTest must be null.");
+    }
     _currentTest = testCase;
     _command = testCase.commands.last;
     if (_process == null) {
       // Start process if not yet started.
       _executable = testCase.commands.last.executable;
       _startProcess(() {
         doStartTest(testCase);
       });
     } else if (testCase.commands.last.executable != _executable) {
       // Restart this runner with the right executable for this test
@@ skipping 576 matching lines @@
     } else {
       return false;
     }
   }
 
   Future runNextCommandWithRetries(TestCase testCase, bool allowRetry) {
     var completer = new Completer();
 
     var nextCommandIndex = testCase.commandOutputs.keys.length;
     var numberOfCommands = testCase.commands.length;
-    Expect.isTrue(nextCommandIndex < numberOfCommands);
+    if (nextCommandIndex >= numberOfCommands) {
+      throw new Exception(
+          "nextCommandIndex must be less than numberOfCommands");
+    }
     var command = testCase.commands[nextCommandIndex];
     var isLastCommand = nextCommandIndex == (numberOfCommands - 1);
 
     void runCommand() {
       var runningProcess = new RunningProcess(testCase, command);
       runningProcess.start().then((CommandOutput commandOutput) {
         if (isLastCommand) {
           // NOTE: We need to call commandOutput.unexpectedOutput here.
           // Calling this getter may result in the side-effect, that
           // commandOutput.requestRetry is set to true.
@@ skipping 52 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
   }
 }