Refactor test.dart.

tools/testing/dart/multitest.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.
 
 #library("multitest");
 
 #import("dart:io");
 #import("test_suite.dart");
 
 // Multitests are Dart test scripts containing lines of the form
@@ skipping 170 matching lines @@
           }
           foundImports.add(relativePath);
           toSearch.add(libraryDir.join(relativePath));
         }
       }
     }
   }
   return foundImports;
 }
 
-void DoMultitest(Path filePath,
-                 String outputDir,
-                 Path suiteDir,
-                 CreateTest doTest,
-                 VoidFunction multitestDone) {
+Future doMultitest(Path filePath, String outputDir, Path suiteDir,
+                   CreateTest doTest) {
   // Each new test is a single String value in the Map tests.
   Map<String, String> tests = new Map<String, String>();
   Map<String, Set<String>> outcomes = new Map<String, Set<String>>();
   ExtractTestsFromMultitest(filePath, tests, outcomes);
 
   Path sourceDir = filePath.directoryPath;
   Path targetDir = CreateMultitestDirectory(outputDir, suiteDir);
   Expect.isNotNull(targetDir);
 
   // Copy all the relative imports of the multitest.
   Set<Path> importsToCopy = _findAllRelativeImports(filePath);
   List<Future> futureCopies = [];
   for (Path importPath in importsToCopy) {
     // Make sure the target directory exists.
     Path importDir = importPath.directoryPath;
     if (!importDir.isEmpty) {
       TestUtils.mkdirRecursive(targetDir, importDir);
     }
     // Copy file.
     futureCopies.add(TestUtils.copyFile(sourceDir.join(importPath),
                                         targetDir.join(importPath)));
   }
 
   // Wait until all imports are copied before scheduling test cases.
-  Futures.wait(futureCopies).then((ignored) {
+  return Futures.wait(futureCopies).transform((_) {
     String baseFilename = filePath.filenameWithoutExtension;
     for (String key in tests.keys) {
       final Path multitestFilename =
           targetDir.append('${baseFilename}_$key.dart');
       final File file = new File.fromPath(multitestFilename);
 
       file.createSync();
       RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
       var bytes = tests[key].charCodes;
       openedFile.writeListSync(bytes, 0, bytes.length);
       openedFile.closeSync();
       Set<String> outcome = outcomes[key];
       bool enableFatalTypeErrors = outcome.contains('static type warning');
       bool hasRuntimeErrors = outcome.contains('runtime error');
       bool hasCompileError = outcome.contains('compile-time error');
       bool isNegativeIfChecked = outcome.contains('dynamic type error');
       doTest(multitestFilename,
              hasCompileError,
              hasRuntimeErrors,
              isNegativeIfChecked: isNegativeIfChecked,
              hasFatalTypeErrors: enableFatalTypeErrors,
              multitestOutcome: outcome);
     }
-    multitestDone();
+
+    return null;

[Emily Fortuna, 2012/11/09 01:41:44]

shouldn't we get rid of these lines if we're returning a Future at line 217?

[Bob Nystrom, 2012/11/09 20:56:26]

This code's a bit hard to read. So the return here is for the function
expression that gets passed to transform(). It works like:

1. futureCopies is a built up list of futures.
2. We pass that to Futures.wait(). That returns a new future that will complete
when everything in the list does.
3. We get that resulting future and call transform() on it.
4. We pass in a function to transform that takes (and discards) the list of
futures, does the work we actually care about and then returns null.
5. transform() returns a future that calls that callback.
6. We return the result of 6 from the method.

Async code is hard to follow. :(

[Emily Fortuna, 2012/11/09 21:03:14]

Oh, I see. And I apparently misread the indentation. Carry on!

   });
 }
 
 
 Path CreateMultitestDirectory(String outputDir, Path suiteDir) {
   final String generatedTestDirectory = 'generated_tests';
   Directory generatedTestDir = new Directory('$outputDir/generated_tests');
   if (!new Directory(outputDir).existsSync()) {
     new Directory(outputDir).createSync();
   }
   if (!generatedTestDir.existsSync()) {
     generatedTestDir.createSync();
   }
   var split = suiteDir.segments();
   if (split.last == 'src') {
     // TODO(sigmund): remove this once all tests are migrated to use
     // TestSuite.forDirectory.
     split.removeLast();
   }
   String path = '${generatedTestDir.path}/${split.last}';
   Directory dir = new Directory(path);
   if (!dir.existsSync()) {
     dir.createSync();
   }
   return new Path.fromNative(new File(path).fullPathSync());
 }