Dart tests: Create generated tests in build directory in test.dart.

tools/testing/dart/multitest.dart

 // Copyright (c) 2011, 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");
 
 // Multitests are Dart test scripts containing lines of the form
 // " [some dart code] /// [key]: [error type]"
 //
 // For each key in the file, a new test file is made containing all
@@ skipping 57 matching lines @@
   contents = null;
   Set<String> validMultitestOutcomes = new Set<String>.from(
       ['compile-time error', 'runtime error',
        'static type error', 'dynamic type error', '']);
   
   List<String> testTemplate = new List<String>();
   testTemplate.add('// Test created from multitest named $filename.');
   // Create the set of multitests, which will have a new test added each
   // time we see a multitest line with a new key.
   Map<String, List<String>> testsAsLines = new Map<String, List<String>>();
-  
+
+  // Matches #import( or #source( followed by " or ' followed by anything
+  // except dart: or /, at the beginning of a line.
+  RegExp relativeImportRegExp =
+      const RegExp('^#(import|source)[(]["\'](?!(dart:|/))');
   for (String line in lines) {
     if (line.contains('///')) {
       var parts = line.split('///')[1].split(':');
       var key = parts[0].trim();
       var rest = parts[1].trim();
       if (testsAsLines.containsKey(key)) {
         Expect.equals('continued', rest);
         testsAsLines[key].add(line);
       } else {
         (testsAsLines[key] = new List<String>.from(testTemplate)).add(line);
         outcomes[key] = rest;
         Expect.isTrue(validMultitestOutcomes.contains(rest));
       }
     } else {
-      if ((line.startsWith('#import(') || line.startsWith('#source(')) &&
-          !line.contains("dart:")) {
-        // TODO(whesse): Rewrite relative paths to reflect temporary directory.
-        tests = [];
-        outcomes = [];
-        return;
-      }
       testTemplate.add(line);
       for (var test in testsAsLines.getValues()) test.add(line);
     }
+    // Warn if any import or source tags have relative paths.
+    if (relativeImportRegExp.hasMatch(line)) {
+      print('Warning: Multitest cannot contain relative imports:');
+      print('    $filename: $line');
+    }
   }
   // Add the template, with no multitest lines, as a test with key 'none'.
   testsAsLines['none'] = testTemplate;
   outcomes['none'] = '';
   
   // Copy all the tests into the output map tests, as multiline strings.
   for (String key in testsAsLines.getKeys()) {
     tests[key] =
         Strings.join(testsAsLines[key], line_separator) + line_separator;
   }
 }
 
 
 void DoMultitest(String filename,
+                 String buildDir,
+                 String testDir,
                  Function doTest(List<String> args,
                                  bool isNegative,
                                  bool isNegativeIfChecked)) {
   // Each new test is a single String value in the Map tests.
   Map<String, String> tests = new Map<String, String>();
   Map<String, String> outcomes = new Map<String, String>();
   ExtractTestsFromMultitest(filename, tests, outcomes);
+
+  String directory = CreateMultitestDirectory(buildDir, testDir);
   String pathSeparator = new Platform().pathSeparator();
   int start = filename.lastIndexOf(pathSeparator) + 1;
   int end = filename.indexOf('.dart', start);
   String baseFilename = filename.substring(start, end);
-  Directory dir = new Directory("");
-  dir.errorHandler =
-      (error) { Expect.fail("Error creating temp directory: $error"); };
-
-  dir.createTempHandler = () {
-    String path = dir.path + new Platform().pathSeparator();
-    Iterator currentKey = tests.getKeys().iterator();
-    WriteMultitestToFileAndQueueIt(tests, outcomes, currentKey,
-                                   '$path$baseFilename', doTest);
-  };
-
-  dir.createTemp();
+  Iterator currentKey = tests.getKeys().iterator();
+  WriteMultitestToFileAndQueueIt(tests, outcomes, currentKey,
+      '$directory$pathSeparator$baseFilename', doTest);
 }
 
 
 // Write multiple tests to files, using tail recursion in a callback
 // to serialize the file operations, rather than opening all files at once.
 WriteMultitestToFileAndQueueIt(Map<String, String> tests,
                                Map<String, String> outcomes,
                                Iterator currentKey,
                                String basePath,
                                Function doTest) {
@@ skipping 21 matching lines @@
     bool isNegativeIfChecked = outcome.contains('type error');
     doTest(filename, isNegative, isNegativeIfChecked);
     // TODO(whesse): Register files and directories to be deleted.
     // They should be registered in a persistent list, so they can
     // be deleted later even if the test script is interrupted.
     WriteMultitestToFileAndQueueIt(tests, outcomes, currentKey,
                                    basePath, doTest);
   };
   file.create();
 }
+
+String CreateMultitestDirectory(String buildDir, String testDir) {
+  final String generatedTestDirectory = 'generated_tests/';
+  Directory parent_dir = new Directory(buildDir + generatedTestDirectory);
+  if (!parent_dir.existsSync()) {
+    parent_dir.createSync();
+  }
+  final String prefix = 'tests/';
+  final String suffix = '/src';
+  Expect.isTrue(testDir.startsWith(prefix));
+  Expect.isTrue(testDir.endsWith(suffix));
+  String path = parent_dir.path +
+      testDir.substring(prefix.length, testDir.length - suffix.length);
+  Directory dir = new Directory(path);
+  if (!dir.existsSync()) {
+    dir.createSync();
+  }
+  return path;
+}