Do not compile tests for different browsers separately

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 732 matching lines @@
                           completeHandler,
                           expectations,
                           isNegative: isNegative,
                           info: info));
     }
   }
 
   List<Command> makeCommands(TestInformation info, var vmOptions, var args) {
     switch (configuration['compiler']) {
     case 'dart2js':
+      var compiledFile = '$tempDir/out-${runtime}.js';
+      var compiledShadowFile = '$tempDir/out_shadow.js';
       args = new List.from(args);
       String tempDir = createOutputDirectory(info.filePath, '');
-      args.add('--out=$tempDir/out.js');
+      args.add('--out=$compiledFile');
 
        List<Command> commands =
-           <Command>[new CompilationCommand("$tempDir/out.js",
+           <Command>[new CompilationCommand(compiledFile,
+                                            compiledShadowFile,
                                             !useSdk,
                                             dart2JsBootstrapDependencies,
                                             compilerPath,
                                             args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'd8') {
         commands.add(new Command(d8FileName, ['$tempDir/out.js']));
       } else if (configuration['runtime'] == 'jsshell') {
         commands.add(new Command(jsShellFileName, ['$tempDir/out.js']));
       }
       return commands;
 
     case 'dart2dart':
+      var compiledFile = '$tempDir/out-${runtime}.dart';
+      var compiledShadowFile = '$tempDir/out_shadow.dart';
       args = new List.from(args);
       args.add('--output-type=dart');
       String tempDir = createOutputDirectory(info.filePath, '');
       args.add('--out=$tempDir/out.dart');
 
       List<Command> commands =
-          <Command>[new CompilationCommand("$tempDir/out.dart",
+          <Command>[new CompilationCommand(compiledFile,
+                                           compiledShadowFile,
                                            !useSdk,
                                            dart2JsBootstrapDependencies,
                                            compilerPath,
                                            args)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
@@ skipping 133 matching lines @@
       // TODO(dart:429): Replace separate replaceAlls with a RegExp when
       // replaceAll(RegExp, String) is implemented.
       String optionsName = '';
       if (getVmOptions(optionsFromFile).length > 1) {
           optionsName = vmOptions.join('-').replaceAll('-','')
                                            .replaceAll('=','')
                                            .replaceAll('/','');
       }
       final String tempDir = createOutputDirectory(info.filePath, optionsName);
 
-      String dartWrapperFilename = '$tempDir/test.dart';
-      String compiledDartWrapperFilename = '$tempDir/test.js';
+      String dartWrapperFilename = '$tempDir/test-${runtime}.dart';
+      String compiledDartWrapperFile = '$tempDir/test-${runtime}.js';
+      String compiledDartWrapperShadowFile = '$tempDir/test_shadow.js';
 
-      String htmlPath = '$tempDir/test.html';
+      String htmlPath = '$tempDir/test-${runtime}.html';
       if (isWrappingRequired && !isWebTest) {
         // test.dart will import the dart test.
         _createWrapperFile(dartWrapperFilename, filePath);
       } else {
         dartWrapperFilename = filename;
       }
       String scriptPath = (compiler == 'none') ?
-          dartWrapperFilename : compiledDartWrapperFilename;
+          dartWrapperFilename : compiledDartWrapperFile;
       scriptPath = _createUrlPathFromFile(new Path(scriptPath));
 
       // Create the HTML file for the test.
       RandomAccessFile htmlTest = new File(htmlPath).openSync(FileMode.WRITE);
       String content = null;
       Path dir = filePath.directoryPath;
       String nameNoExt = filePath.filenameWithoutExtension;
       Path pngPath = dir.append('$nameNoExt.png');
       Path txtPath = dir.append('$nameNoExt.txt');
       Path expectedOutput = null;
       if (new File.fromPath(pngPath).existsSync()) {
         expectedOutput = pngPath;
         content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"));
       } else if (new File.fromPath(txtPath).existsSync()) {
         expectedOutput = txtPath;
         content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"));
       } else {
         content = getHtmlContents(filename, scriptType,
             new Path("$scriptPath"));
       }
       htmlTest.writeStringSync(content);
       htmlTest.closeSync();
 
       // Construct the command(s) that compile all the inputs needed by the
       // browser test. For running Dart in DRT, this will be noop commands.
       List<Command> commands = [];
       if (compiler != 'none') {
         commands.add(_compileCommand(
-            dartWrapperFilename, compiledDartWrapperFilename,
-            compiler, tempDir, vmOptions, optionsFromFile));
+            dartWrapperFilename, compiledDartWrapperFile,
+            compiledDartWrapperShadowFile, 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);
         String baseName = namePath.filenameWithoutExtension;
         Path fromPath = filePath.directoryPath.join(namePath);
         if (compiler != 'none') {
           assert(namePath.extension == 'dart');
+          // NOTE: There is a tiny chance that this file will be accessed
+          // by two concurrent dart2js compile commands.
+          var compiledFile = '$tempDir/$baseName.js';
+          var compiledShadowFile = '$tempDir/${baseName}_shadow.js';
+
           commands.add(_compileCommand(
-              fromPath.toNativePath(), '$tempDir/$baseName.js',
+              fromPath.toNativePath(), compiledFile, compiledShadowFile,
               compiler, tempDir, vmOptions, optionsFromFile));
         }
         if (compiler == 'none') {
           // For the tests that require multiple input scripts but are not
           // compiled, move the input scripts over with the script so they can
           // be accessed.
           String result = new File.fromPath(fromPath).readAsStringSync();
           new File('$tempDir/$baseName.dart').writeAsStringSync(result);
         }
       }
@@ skipping 99 matching lines @@
         }
 
         doTest(testCase);
         subtestIndex++;
       } while(subtestIndex < subtestNames.length);
     }
   }
 
   /** Helper to create a compilation command for a single input file. */
   Command _compileCommand(String inputFile, String outputFile,
-      String compiler, String dir, vmOptions, optionsFromFile) {
+      String shadowFile, String compiler, String dir, vmOptions,
+      optionsFromFile) {
     String executable = compilerPath;
     List<String> args = TestUtils.standardOptions(configuration);
     switch (compiler) {
       case 'dart2js':
       case 'dart2dart':
         String packageRoot =
           packageRootArgument(optionsFromFile['packageRoot']);
         if (packageRoot != null) {
           args.add(packageRoot);
         }
         args.add('--out=$outputFile');
         args.add(inputFile);
         break;
       default:
         print('unimplemented compiler $compiler');
         exit(1);
     }
     if (executable.endsWith('.dart')) {
       // Run the compiler script via the Dart VM.
       args.insert(0, executable);
       executable = dartShellFileName;
     }
     if (['dart2js', 'dart2dart'].contains(configuration['compiler'])) {
       return new CompilationCommand(outputFile,
+                                   shadowFile,
                                    !useSdk,
                                    dart2JsBootstrapDependencies,
                                    compilerPath,
                                    args);
     }
     return new Command(executable, args);
   }
 
   /**
    * Create a directory for the generated test.  If a Dart language test
@@ skipping 16 matching lines @@
       testUniqueName = '$testUniqueName-$optionsName';
     }
 
     // Create '[build dir]/generated_tests/$compiler-$runtime/$testUniqueName',
     // including any intermediate directories that don't exist.
     // If the tests are run in checked or minified mode we add that to the
     // '$compile-$runtime' directory name.
     var checked = configuration['checked'] ? '-checked' : '';
     var minified = configuration['minified'] ? '-minified' : '';
     var csp = configuration['csp'] ? '-csp' : '';
-    var dirName = "${configuration['compiler']}-${configuration['runtime']}"
-                  "$checked$minified$csp";
+    var dirName = "${configuration['compiler']}$checked$minified$csp";
     Path generatedTestPath = new Path(buildDir)
         .append('generated_tests')
         .append(dirName)
         .append(testUniqueName);
 
     TestUtils.mkdirRecursive(new Path('.'), generatedTestPath);
     return new File.fromPath(generatedTestPath).fullPathSync()
         .replaceAll('\\', '/');
   }
 
@@ skipping 785 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);
    }
 }