Upload new Dart binaries and re-enable unit tests for test scripts.

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 574 matching lines @@
     var listCompleter = new Completer();
     group.add(listCompleter.future);
 
     var lister = dir.list(recursive: listRecursively);
     lister.onFile = (file) => enqueueFile(file, group);
     lister.onDone = listCompleter.complete;
   }
 
   void enqueueFile(String filename, FutureGroup group) {
     if (!isTestFile(filename)) return;
-    Path filePath = new Path.fromNative(filename);
+    Path filePath = new Path(filename);
 
     // Only run the tests that match the pattern.
     RegExp pattern = configuration['selectors'][suiteName];
     if (!pattern.hasMatch('$filePath')) return;
     if (filePath.filename.endsWith('test_config.dart')) return;
 
     var optionsFromFile = readOptionsFromFile(filePath);
     CreateTest createTestCase = makeTestCaseCreator(optionsFromFile);
 
     if (optionsFromFile['isMultitest']) {
@@ skipping 297 matching lines @@
       if (new File.fromPath(pngPath).existsSync()) {
         expectedOutput = pngPath;
         // TODO(efortuna): Unify path libraries in test.dart.
         content = getHtmlLayoutContents(scriptType, pathLib.relative(scriptPath,
             from: pathLib.dirname(htmlPath)));
       } else if (new File.fromPath(txtPath).existsSync()) {
         expectedOutput = txtPath;
         content = getHtmlLayoutContents(scriptType, pathLib.relative(scriptPath,
             from: pathLib.dirname(htmlPath)));
       } else {
-        final htmlLocation = new Path.fromNative(htmlPath);
+        final htmlLocation = new Path(htmlPath);
         content = getHtmlContents(
           filename,
           dartDir.append('pkg/unittest/test_controller.js')
               .relativeTo(htmlLocation),
           dartDir.append('pkg/browser/lib/dart.js').relativeTo(htmlLocation),
           scriptType,
-          new Path.fromNative(scriptPath).relativeTo(htmlLocation));
+          new Path(scriptPath).relativeTo(htmlLocation));
       }
       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,
@@ skipping 170 matching lines @@
     }
 
     // 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 dirName = "${configuration['compiler']}-${configuration['runtime']}"
                   "$checked$minified";
-    Path generatedTestPath = new Path.fromNative(dartDir.toNativePath())
+    Path generatedTestPath = new Path(dartDir.toNativePath())
         .append(buildDir)
         .append('generated_tests')
         .append(dirName)
         .append(testUniqueName);
 
     TestUtils.mkdirRecursive(new Path('.'), generatedTestPath);
     return new File.fromPath(generatedTestPath).fullPathSync()
         .replaceAll('\\', '/');
   }
 
@@ skipping 320 matching lines @@
 class DartcCompilationTestSuite extends StandardTestSuite {
   List<String> _testDirs;
 
   DartcCompilationTestSuite(Map configuration,
                             String suiteName,
                             String directoryPath,
                             List<String> this._testDirs,
                             List<String> expectations)
       : super(configuration,
               suiteName,
-              new Path.fromNative(directoryPath),
+              new Path(directoryPath),
               expectations);
 
   List<String> additionalOptions(Path filePath) {
     return ['--fatal-warnings', '--fatal-type-errors'];
   }
 
   Future enqueueTests() {
     var group = new FutureGroup();
 
     for (String testDir in _testDirs) {
@@ skipping 148 matching lines @@
 class TestUtils {
   /**
    * The libraries in this directory relies on finding various files
    * relative to the 'test.dart' script in '.../dart/tools/test.dart'. If
    * the main script using 'test_suite.dart' is not there, the main
    * script must set this to '.../dart/tools/test.dart'.
    */
   static String testScriptPath = new Options().script;
   static LastModifiedCache lastModifiedCache = new LastModifiedCache();
   static Path currentWorkingDirectory =
-      new Path.fromNative(new Directory.current().path);
+      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(),
@@ skipping 58 matching lines @@
     } else if (system == 'macos') {
       result = 'xcodebuild/';
     } else if (system == 'windows') {
       result = 'build/';
     }
     return result;
   }
 
   static Path dartDir() {
     File scriptFile = new File(testScriptPath);
-    Path scriptPath = new Path.fromNative(scriptFile.fullPathSync());
+    Path scriptPath = new Path(scriptFile.fullPathSync());
     return scriptPath.directoryPath.directoryPath;
   }
 
   static List<String> standardOptions(Map configuration) {
     List args = ["--ignore-unrecognized-flags"];
     if (configuration["checked"]) {
       args.add('--enable_asserts');
       args.add("--enable_type_checks");
     }
     String compiler = configuration["compiler"];
@@ skipping 128 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);
    }
 }