Remove use of Expect from test scripts and idlparser_test.

tools/testing/dart/test_suite.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 enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 379 matching lines @@
   bool hasCompileError;
   bool hasRuntimeError;
   bool isNegativeIfChecked;
   bool hasFatalTypeErrors;
   Set<String> multitestOutcome;
 
   TestInformation(this.filePath, this.optionsFromFile,
                   this.hasCompileError, this.hasRuntimeError,
                   this.isNegativeIfChecked, this.hasFatalTypeErrors,
                   this.multitestOutcome) {
-    Expect.isTrue(filePath.isAbsolute);
+    assert(filePath.isAbsolute);
   }
 }
 
 /**
  * A standard [TestSuite] implementation that searches for tests in a
  * directory, and creates [TestCase]s that compile and/or run them.
  */
 class StandardTestSuite extends TestSuite {
   final Path suiteDir;
   final List<String> statusFilePaths;
@@ skipping 110 matching lines @@
    * If DumpRenderTree/Dartium is required, and not yet updated, waits for
    * the update then completes. Otherwise completes immediately.
    */
   Future updateDartium() {
     var completer = new Completer();
     var updater = runtimeUpdater(configuration);
     if (updater == null || updater.updated) {
       return new Future.immediate(null);
     }
 
-    Expect.isTrue(updater.isActive);
+    assert(updater.isActive);
     updater.onUpdated.add(() => completer.complete(null));
 
     return completer.future;
   }
 
   /**
    * Reads the status files and completes with the parsed expectations.
    */
   Future<TestExpectations> readExpectations() {
     var completer = new Completer();
@@ skipping 88 matching lines @@
       // Multitests do not run on browsers.
       if (TestUtils.isBrowserRuntime(configuration['runtime'])) return;
       // Multitests are in [build directory]/generated_tests/... .
       // The test name will be '[test filename (no extension)]/[multitest key].
       String name = filePath.filenameWithoutExtension;
       int middle = name.lastIndexOf('_');
       testName = '${name.substring(0, middle)}/${name.substring(middle + 1)}';
     } else {
       // The test name is the relative path from the test suite directory to
       // the test, with the .dart extension removed.
-      Expect.isTrue(filePath.toNativePath().startsWith(
+      assert(filePath.toNativePath().startsWith(
                     suiteDir.toNativePath()));
       var testNamePath = filePath.relativeTo(suiteDir);
-      Expect.isTrue(testNamePath.extension == 'dart');
+      assert(testNamePath.extension == 'dart');
       if (testNamePath.extension == 'dart') {
         testName = testNamePath.directoryPath.append(
             testNamePath.filenameWithoutExtension).toString();
       }
     }
     int shards = configuration['shards'];
     if (shards > 1) {
       int shard = configuration['shard'];
       if (testName.hashCode % shards != shard - 1) {
         return;
@@ skipping 56 matching lines @@
       // format of the error line
       if (info.hasFatalTypeErrors) {
         isNegative = true;
       }
     }
 
     var commonArguments = commonArgumentsFromFile(info.filePath,
                                                   info.optionsFromFile);
 
     List<List<String>> vmOptionsList = getVmOptions(info.optionsFromFile);
-    Expect.isFalse(vmOptionsList.isEmpty, "empty vmOptionsList");
+    assert(!vmOptionsList.isEmpty);
 
     for (var vmOptions in vmOptionsList) {
       doTest(new TestCase('$suiteName/$testName',
                           makeCommands(info, vmOptions, commonArguments),
                           configuration,
                           completeHandler,
                           expectations,
                           isNegative: isNegative,
                           info: info));
     }
@@ skipping 98 matching lines @@
 
     var fileString = file.toString();
     if (fileString.startsWith(buildDir.toString())) {
       var fileRelativeToBuildDir = file.relativeTo(buildDir);
       return "/$PREFIX_BUILDDIR/$fileRelativeToBuildDir";
     } else if (fileString.startsWith(dartDir.toString())) {
       var fileRelativeToDartDir = file.relativeTo(dartDir);
       return "/$PREFIX_DARTDIR/$fileRelativeToDartDir";
     }
     // Unreachable
-    Expect.fail('This should be unreachable.');
+    print("Cannot create URL for path $file. Not in build or dart directory.");
+    exit(1);
   }
 
   String _getUriForBrowserTest(TestInformation info,
                             String pathComponent,
                             subtestNames,
                             subtestIndex) {
     // Note: If we run test.py with the "--list" option, no http servers
     // will be started. So we use PORT/CROSS_ORIGIN_PORT instead of real ports.
     var serverPort = "PORT";
     var crossOriginPort = "CROSS_ORIGIN_PORT";
     if (!configuration['list']) {
-      Expect.isTrue(configuration.containsKey('_servers_'));
+      assert(configuration.containsKey('_servers_'));
       serverPort = configuration['_servers_'].port;
       crossOriginPort = configuration['_servers_'].crossOriginPort;
     }
 
     var url= 'http://127.0.0.1:$serverPort$pathComponent'
         '?crossOriginPort=$crossOriginPort';
     if (info.optionsFromFile['isMultiHtmlTest'] && subtestNames.length > 0) {
       url= '${url}&group=${subtestNames[subtestIndex]}';
     }
     return url;
@@ skipping 101 matching lines @@
       List<Command> commands = [];
       if (compiler != 'none') {
         commands.add(_compileCommand(
             dartWrapperFilename, compiledDartWrapperFilename,
             compiler, tempDir, vmOptions, optionsFromFile));
 
         // some tests require compiling multiple input scripts.
         List<String> otherScripts = optionsFromFile['otherScripts'];
         for (String name in otherScripts) {
           Path namePath = new Path(name);
-          Expect.equals(namePath.extension, 'dart');
+          assert(namePath.extension == 'dart');
           String baseName = namePath.filenameWithoutExtension;
           Path fromPath = filePath.directoryPath.join(namePath);
           commands.add(_compileCommand(
               fromPath.toNativePath(), '$tempDir/$baseName.js',
               compiler, tempDir, vmOptions, optionsFromFile));
         }
       }
 
       // Variables for browser multi-tests.
       List<String> subtestNames = info.optionsFromFile['subtestNames'];
@@ skipping 21 matching lines @@
               '--timeout=${configuration["timeout"]~/2}',
               '--out=$fullHtmlPath'];
           if (runtime == 'dartium') {
             args.add('--executable=$dartiumFilename');
           }
           if (subtestIndex != 0) {
             args.add('--force-refresh');
           }
           commandSet.add(new Command('python', args));
         } else {
-          Expect.isTrue(runtime == "drt");
+          if (runtime != "drt") {
+            print("Unknown runtime $runtime");
+            exit(1);
+          }
 
           var dartFlags = [];
           var dumpRenderTreeOptions = [];
 
           dumpRenderTreeOptions.add('--no-timeout');
 
           if (compiler == 'none' || compiler == 'dart2dart') {
             dartFlags.add('--ignore-unrecognized-flags');
             if (configuration["checked"]) {
               dartFlags.add('--enable_asserts');
@@ skipping 52 matching lines @@
       case 'dart2dart':
         String packageRoot =
           packageRootArgument(optionsFromFile['packageRoot']);
         if (packageRoot != null) {
           args.add(packageRoot);
         }
         args.add('--out=$outputFile');
         args.add(inputFile);
         break;
       default:
-        Expect.fail('unimplemented compiler $compiler');
+        print('unimplemented compiler $compiler');
+        exit(1);
     }
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insertRange(0, 1, executable);
       executable = dartShellFileName;
     }
     if (['dart2js', 'dart2dart'].contains(configuration['compiler'])) {
       return new CompilationCommand(outputFile,
                                    !useSdk,
                                    dart2JsBootstrapDependencies,
@@ skipping 46 matching lines @@
   String get scriptType {
     switch (configuration['compiler']) {
       case 'none':
       case 'dart2dart':
         return 'application/dart';
       case 'dart2js':
       case 'dartanalyzer':
       case 'dartc':
         return 'text/javascript';
       default:
-        Expect.fail('Non-web runtime, so no scriptType for: '
+        print('Non-web runtime, so no scriptType for: '
                     '${configuration["compiler"]}');
+        exit(1);
         return null;
     }
   }
 
   bool get hasRuntime {
     switch(configuration['runtime']) {
       case 'none':
         return false;
       default:
         return true;
@@ skipping 42 matching lines @@
       args.add(packageRoot);
     }
     args.addAll(additionalOptions(filePath));
     if (configuration['analyzer']) {
       args.add('--machine');
     }
 
     bool isMultitest = optionsFromFile["isMultitest"];
     List<String> dartOptions = optionsFromFile["dartOptions"];
     List<List<String>> vmOptionsList = getVmOptions(optionsFromFile);
-    Expect.isTrue(!isMultitest || dartOptions == null);
+    assert(!isMultitest || dartOptions == null);
     if (dartOptions == null) {
       args.add(filePath.toNativePath());
     } else {
       var executable_name = dartOptions[0];
       // TODO(ager): Get rid of this hack when the runtime checkout goes away.
       var file = new File(executable_name);
       if (!file.existsSync()) {
         executable_name = '../$executable_name';
-        Expect.isTrue(new File(executable_name).existsSync());
+        assert(new File(executable_name).existsSync());
         dartOptions[0] = executable_name;
       }
       args.addAll(dartOptions);
     }
 
     return args;
   }
 
   String packageRoot(String packageRootFromFile) {
     if (packageRootFromFile == "none") {
@@ skipping 464 matching lines @@
       new Path(new Directory.current().path);
   /**
    * Creates a directory using a [relativePath] to an existing
    * [base] directory if that [relativePath] does not already exist.
    */
   static Directory mkdirRecursive(Path base, Path relativePath) {
     if (relativePath.isAbsolute) {
       base = new Path('/');
     }
     Directory dir = new Directory.fromPath(base);
-    Expect.isTrue(dir.existsSync(),
-                  "Expected ${dir} to already exist");
+    assert(dir.existsSync());
     var segments = relativePath.segments();
     for (String segment in segments) {
       base = base.append(segment);
       if (base.toString() == "/$segment" &&
           segment.length == 2 &&
           segment.endsWith(':')) {
         // Skip the directory creation for a path like "/E:".
         continue;
       }
       dir = new Directory.fromPath(base);
       if (!dir.existsSync()) {
         dir.createSync();
       }
-      Expect.isTrue(dir.existsSync(), "Failed to create ${dir.path}");
+      assert(dir.existsSync());
     }
     return dir;
   }
 
   /**
    * Copy a [source] file to a new place.
    * Assumes that the directory for [dest] already exists.
    */
   static Future copyFile(Path source, Path dest) {
     return new File.fromPath(source).openRead()
@@ skipping 194 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }