Migration of testing scripts in tools/ to libv2

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,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 library test_suite;
 
+import "dart:async";
 import "dart:io";
 import "dart:isolate";
 import "status_file_parser.dart";
 import "test_runner.dart";
 import "multitest.dart";
 import "drt_updater.dart";
 import "dart:uri";
 
 part "browser_test.dart";
 
@@ skipping 30 matching lines @@
 }
 
 /** A completer that waits until all added [Future]s complete. */
 // TODO(rnystrom): Copied from web_components. Remove from here when it gets
 // added to dart:core. (See #6626.)
 class FutureGroup {
   const _FINISHED = -1;
   int _pending = 0;
   Completer<List> _completer = new Completer<List>();
   final List<Future> futures = <Future>[];
+  bool wasCompleted = false;
 
   /**
    * Wait for [task] to complete (assuming this barrier has not already been
    * marked as completed, otherwise you'll get an exception indicating that a
    * future has already been completed).
    */
   void add(Future task) {
     if (_pending == _FINISHED) {
-      throw new FutureAlreadyCompleteException();
+      throw new Exception("FutureFutureAlreadyCompleteException");
     }
     _pending++;
-    futures.add(task);
-    task.handleException(
-        (e) => _completer.completeException(e, task.stackTrace));
-    task.then((_) {
+    var handledTaskFuture = task.catchError((e) {

[Bill Hesse, 2013/01/09 18:21:06]

Couldn't you just put parentheses around all this, and add it to futures where
it was added before?

[kustermann, 2013/01/09 18:27:40]

I think it is a bit more readable this way.

+      if (!wasCompleted) {
+        _completer.completeError(e.error, task.stackTrace);
+        wasCompleted = true;
+      }
+    }).then((_) {
       _pending--;
       if (_pending == 0) {
         _pending = _FINISHED;
-        _completer.complete(futures);
+        if (!wasCompleted) {
+          _completer.complete(futures);
+          wasCompleted = true;
+        }
       }
     });
+    futures.add(handledTaskFuture);
   }
 
   Future<List> get future => _completer.future;
 }
 
 /**
  * A TestSuite represents a collection of tests.  It creates a [TestCase]
  * object for each test to be run, and passes the test cases to a callback.
  *
  * Most TestSuites represent a directory or directory tree containing tests,
@@ skipping 167 matching lines @@
       p.onExit = (code) {
         if (code < 0) {
           print("Failed to list tests: $runnerPath --list");
           replyTo.send("");
         } else {
           processExited = true;
           checkDone();
         }
       };
       port.close();
-    });
-    processFuture.handleException((e) {
+    }).catchError((e) {
       print("Failed to list tests: $runnerPath --list");
       replyTo.send("");
       return true;
     });
   });
 }
 
 
 /**
  * A specialized [TestSuite] that runs tests written in C to unit test
@@ skipping 180 matching lines @@
   bool isTestFile(String filename) {
     // Use the specified predicate, if provided.
     if (isTestFilePredicate != null) return isTestFilePredicate(filename);
 
     return filename.endsWith("Test.dart");
   }
 
   List<String> additionalOptions(Path filePath) => [];
 
   void forEachTest(TestCaseEvent onTest, Map testCache, [VoidFunction onDone]) {
-    updateDartium().chain((_) {
+    updateDartium().then((_) {
       doTest = onTest;
 
       return readExpectations();
-    }).chain((expectations) {
+    }).then((expectations) {
       testExpectations = expectations;
 
       // Checked if we have already found and generated the tests for
       // this suite.
       if (!testCache.containsKey(suiteName)) {
         cachedTests = testCache[suiteName] = [];
         return enqueueTests();
       } else {
         // We rely on enqueueing completing asynchronously.
         return asynchronously(() {
@@ skipping 53 matching lines @@
       ReadTestExpectationsInto(expectations,
                                dartDir.append(statusFilePath).toNativePath(),
                                configuration, statusFileRead);
     }
 
     return completer.future;
   }
 
   Future enqueueTests() {
     Directory dir = new Directory.fromPath(suiteDir);
-    return dir.exists().chain((exists) {
+    return dir.exists().then((exists) {
       if (!exists) {
         print('Directory containing tests missing: ${suiteDir.toNativePath()}');
         return new Future.immediate(null);
       } else {
         var group = new FutureGroup();
         enqueueDirectory(dir, group);
         return group.future;
       }
     });
   }
@@ skipping 747 matching lines @@
     // Find the options in the file.
     List<List> result = new List<List>();
     List<String> dartOptions;
     String packageRoot;
     bool hasCompileError = contents.contains("@compile-error");
     bool hasRuntimeError = contents.contains("@runtime-error");
     bool isStaticClean = false;
 
     Iterable<Match> matches = testOptionsRegExp.allMatches(contents);
     for (var match in matches) {
-      result.add(match[1].split(' ').filter((e) => e != ''));
+      result.add(match[1].split(' ').where((e) => e != '').toList());
     }
     if (result.isEmpty) result.add([]);
 
     matches = dartOptionsRegExp.allMatches(contents);
     for (var match in matches) {
       if (dartOptions != null) {
         throw new Exception(
             'More than one "// DartOptions=" line in test $filePath');
       }
-      dartOptions = match[1].split(' ').filter((e) => e != '');
+      dartOptions = match[1].split(' ').where((e) => e != '').toList();
     }
 
     matches = packageRootRegExp.allMatches(contents);
     for (var match in matches) {
       if (packageRoot != null) {
         throw new Exception(
             'More than one "// PackageRoot=" line in test $filePath');
       }
       packageRoot = match[1];
       if (packageRoot != 'none') {
         // PackageRoot=none means that no package-root option should be given.
         packageRoot = '${filePath.directoryPath.join(new Path(packageRoot))}';
       }
     }
 
     matches = staticCleanRegExp.allMatches(contents);
     for (var match in matches) {
       if (isStaticClean) {
         throw new Exception(
             'More than one "// @static-clean=" line in test $filePath');
       }
       isStaticClean = true;
     }
 
     List<String> otherScripts = new List<String>();
     matches = otherScriptsRegExp.allMatches(contents);
     for (var match in matches) {
-      otherScripts.addAll(match[1].split(' ').filter((e) => e != ''));
+      otherScripts.addAll(match[1].split(' ').where((e) => e != '').toList());
     }
 
     bool isMultitest = multiTestRegExp.hasMatch(contents);
     bool isMultiHtmlTest = multiHtmlTestRegExp.hasMatch(contents);
     bool containsLeadingHash = leadingHashRegExp.hasMatch(contents);
     Match isolateMatch = isolateStubsRegExp.firstMatch(contents);
     String isolateStubs = isolateMatch != null ? isolateMatch[1] : '';
     bool containsDomImport = domImportRegExp.hasMatch(contents);
     bool isLibraryDefinition = libraryDefinitionRegExp.hasMatch(contents);
     bool containsSourceOrImport = sourceOrImportRegExp.hasMatch(contents);
     int numStaticTypeAnnotations = 0;
     for (var i in staticTypeRegExp.allMatches(contents)) {
       numStaticTypeAnnotations++;
     }
     int numCompileTimeAnnotations = 0;
     for (var i in compileTimeRegExp.allMatches(contents)) {
       numCompileTimeAnnotations++;
     }
 
     // Note: This is brittle. It's the age-old problem of having a context free
     // language but the means to easily identify the construct is a regular
     // expression, aka impossible. Therefore we just make an approximation of
     // the number of top-level "group(...)" occurrences. This assumes you import
     // unittest with no prefix and always directly call "group(". It only uses
     // top-level "groups" so tests running nested groups will be no-ops.
     RegExp numTests = new RegExp(r"\s*[^/]\s*group\('[^,']*");
     List<String> subtestNames = [];
-    Iterator matchesIter = numTests.allMatches(contents).iterator();
-    while(matchesIter.hasNext && isMultiHtmlTest) {
-      String fullMatch = matchesIter.next().group(0);
+    Iterator matchesIter = numTests.allMatches(contents).iterator;
+    while(matchesIter.moveNext() && isMultiHtmlTest) {
+      String fullMatch = matchesIter.current.group(0);
       subtestNames.add(fullMatch.substring(fullMatch.indexOf("'") + 1));
     }
 
     return { "vmOptions": result,
              "dartOptions": dartOptions,
              "packageRoot": packageRoot,
              "hasCompileError": hasCompileError,
              "hasRuntimeError": hasRuntimeError,
              "isStaticClean" : isStaticClean,
              "otherScripts": otherScripts,
@@ skipping 404 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);
    }
 }