Land update to tools directory with new binaries.

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 54 matching lines @@
   }
   file.closeSync();
   String contents = new String.fromCharCodes(chars);
   chars = null;
   int first_newline = contents.indexOf('\n');
   final String line_separator =
       (first_newline == 0 || contents[first_newline - 1] != '\r')
       ? '\n'
       : '\r\n';
   List<String> lines = contents.split(line_separator);
-  if (lines.last() == '') lines.removeLast();
+  if (lines.last == '') lines.removeLast();
   contents = null;
   Set<String> validMultitestOutcomes = new Set<String>.from(
       ['compile-time error', 'runtime error',
        'static type warning', 'dynamic type error']);
 
   List<String> testTemplate = new List<String>();
   testTemplate.add(
       '// Test created from multitest named ${filePath.toNativePath()}.');
   // Create the set of multitests, which will have a new test added each
   // time we see a multitest line with a new key.
@@ skipping 15 matching lines @@
           outcomes[annotation.key].add(nextOutcome);
           if (!validMultitestOutcomes.contains(nextOutcome)) {
             Expect.fail(
               "Invalid test directive '$nextOutcome' on line ${lineCount}:\n"
               "${annotation.rest} ");
           }
         }
       }
     } else {
       testTemplate.add(line);
-      for (var test in testsAsLines.getValues()) test.add(line);
+      for (var test in testsAsLines.values) test.add(line);
     }
   }
 
   // Check that every key (other than the none case) has at least one outcome
-  for (var outcomeKey in outcomes.getKeys()) {
-    if (outcomeKey != 'none' && outcomes[outcomeKey].isEmpty()) {
+  for (var outcomeKey in outcomes.keys) {
+    if (outcomeKey != 'none' && outcomes[outcomeKey].isEmpty) {
       Expect.fail("Test ${outcomeKey} has no valid annotated outcomes.\n"
                   "Expected one of: ${validMultitestOutcomes.toString()}");
     }
   }
 
   // Add the template, with no multitest lines, as a test with key 'none'.
   testsAsLines['none'] = testTemplate;
   outcomes['none'] = new Set<String>();
 
   // Copy all the tests into the output map tests, as multiline strings.
-  for (String key in testsAsLines.getKeys()) {
+  for (String key in testsAsLines.keys) {
     tests[key] =
         Strings.join(testsAsLines[key], line_separator).concat(line_separator);
   }
 }
 
 // Represents a mutlitest annotation in the special /// comment.
 class _Annotation {
   String key;
   String rest;
   List<String> outcomesList;
@@ skipping 15 matching lines @@
 // Find all relative imports and copy them into the dir that contains
 // the generated tests.
 Set<Path> _findAllRelativeImports(Path topLibrary) {
   Set<Path> toSearch = new Set<Path>.from([topLibrary]);
   Set<Path> foundImports = new HashSet<Path>();
   Path libraryDir = topLibrary.directoryPath;
   // Matches #import( or #source( followed by " or ' followed by anything
   // except dart:, dart-ext: or /, at the beginning of a line.
   RegExp relativeImportRegExp = const RegExp(
       '^#(import|source)[(]["\'](?!(dart:|dart-ext:|/))([^"\']*)["\']');
-  while (!toSearch.isEmpty()) {
+  while (!toSearch.isEmpty) {
     var thisPass = toSearch;
     toSearch = new HashSet<Path>();
     for (Path filename in thisPass) {
       File f = new File.fromPath(filename);
       for (String line in f.readAsLinesSync()) {
         Match match = relativeImportRegExp.firstMatch(line);
         if (match != null) {
           Path relativePath = new Path(match.group(3));
           if (foundImports.contains(relativePath)) {
             continue;
@@ skipping 37 matching lines @@
       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) {
     String baseFilename = filePath.filenameWithoutExtension;
-    for (String key in tests.getKeys()) {
+    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();
+      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();
   });
 }
 
 
 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') {
+  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()}';
+  String path = '${generatedTestDir.path}/${split.last}';
   Directory dir = new Directory(path);
   if (!dir.existsSync()) {
     dir.createSync();
   }
   return new Path.fromNative(new File(path).fullPathSync());
 }