Clean up some warnings and deprecated calls.

utils/tests/pub/test_pub.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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
@@ skipping 562 matching lines @@
             'Pub returned exit code ${result.exitCode}, expected $exitCode.');
       }
 
       if (failures.length > 0) {
         if (error == null) {
           // If we aren't validating the error, still show it on failure.
           failures.add('Pub stderr:');
           failures.addAll(result.stderr.map((line) => '| $line'));
         }
 
-        throw new ExpectException(Strings.join(failures, '\n'));
+        throw new ExpectException(failures.join('\n'));
       }
 
       return null;
     });
   });
 }
 
 /// Starts a Pub process and returns a [ScheduledProcess] that supports
 /// interaction with that process.
 ///
@@ skipping 142 matching lines @@
 
   if (expected is RegExp) {
     _validateOutputRegex(failures, pipe, expected, actual);
   } else {
     _validateOutputString(failures, pipe, expected, actual);
   }
 }
 
 void _validateOutputRegex(List<String> failures, String pipe,
                           RegExp expected, List<String> actual) {
-  var actualText = Strings.join(actual, '\n');
+  var actualText = actual.join('\n');
   if (actualText.contains(expected)) return;
 
   if (actual.length == 0) {
     failures.add('Expected $pipe to match "${expected.pattern}" but got none.');
   } else {
     failures.add('Expected $pipe to match "${expected.pattern}" but got:');
     failures.addAll(actual.map((line) => '| $line'));
   }
 }
 
@@ skipping 188 matching lines @@
 
       throw new ExpectException(
           'File $file should contain:\n\n$textContents\n\n'
           'but contained:\n\n$text');
     });
   }
 
   /// Loads the contents of the file.
   ByteStream load(List<String> path) {
     if (!path.isEmpty) {
-      var joinedPath = Strings.join(path, '/');
-      throw "Can't load $joinedPath from within $name: not a directory.";
+      throw "Can't load ${path.join('/')} from within $name: not a directory.";
     }
 
     return new ByteStream.fromBytes(contents);
   }
 }
 
 /// Describes a directory and its contents. These are used both for setting up
 /// an expected directory tree before running a test, and for validating that
 /// the file system matches some expectations after running it.
 class DirectoryDescriptor extends Descriptor {
@@ skipping 45 matching lines @@
     if (path.isEmpty) {
       throw "Can't load the contents of $name: is a directory.";
     }
 
     for (var descriptor in contents) {
       if (descriptor.name == path[0]) {
         return descriptor.load(path.getRange(1, path.length - 1));
       }
     }
 
-    throw "Directory $name doesn't contain ${Strings.join(path, '/')}.";
+    throw "Directory $name doesn't contain ${path.join('/')}.";
   }
 }
 
 /// Wraps a [Future] that will complete to a [Descriptor] and makes it behave
 /// like a concrete [Descriptor]. This is necessary when the contents of the
 /// descriptor depends on information that's not available until part of the
 /// test run is completed.
 class FutureDescriptor extends Descriptor {
   Future<Descriptor> _future;
 
@@ skipping 63 matching lines @@
       var command = commands.removeAt(0);
       return _runGit(command, workingDir).then(runGitStep);
     }
 
     return super.create(parentDir).then((rootDir) {
       workingDir = rootDir;
       return runGitStep(null);
     });
   }
 
-  Future<String> _runGit(List<String> args, Directory workingDir) {
+  Future<List<String>> _runGit(List<String> args, Directory workingDir) {
     // Explicitly specify the committer information. Git needs this to commit
     // and we don't want to rely on the buildbots having this already set up.
     var environment = {
       'GIT_AUTHOR_NAME': 'Pub Test',
       'GIT_AUTHOR_EMAIL': 'pub@dartlang.org',
       'GIT_COMMITTER_NAME': 'Pub Test',
       'GIT_COMMITTER_EMAIL': 'pub@dartlang.org'
     };
 
     return gitlib.run(args, workingDir: workingDir.path,
@@ skipping 27 matching lines @@
     throw "TODO(nweiz): implement this";
   }
 
   Future delete(dir) {
     throw new UnsupportedError('');
   }
 
   /// Loads the contents of this tar file.
   ByteStream load(List<String> path) {
     if (!path.isEmpty) {
-      var joinedPath = Strings.join(path, '/');
-      throw "Can't load $joinedPath from within $name: not a directory.";
+      throw "Can't load ${path.join('/')} from within $name: not a directory.";
     }
 
     var controller = new StreamController<List<int>>();
     // TODO(nweiz): propagate any errors to the return value. See issue 3657.
     withTempDir((tempDir) {
       return create(tempDir).then((tar) {
         var sourceStream = tar.openInputStream();
         return store(wrapInputStream(sourceStream), controller);
       });
     });
@@ skipping 13 matching lines @@
       if (entryExists(join(dir, name))) {
         throw new ExpectException('File $name in $dir should not exist.');
       }
     });
   }
 
   ByteStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: it doesn't exist.";
     } else {
-      throw "Can't load ${Strings.join(path, '/')} from within $name: $name "
-        "doesn't exist.";
+      throw "Can't load ${path.join('/')} from within $name: $name doesn't "
+        "exist.";
     }
   }
 }
 
 /// A function that creates a [Validator] subclass.
 typedef Validator ValidatorCreator(Entrypoint entrypoint);
 
 /// Schedules a single [Validator] to run on the [appPath]. Returns a scheduled
 /// Future that contains the errors and warnings produced by that validator.
 Future<Pair<List<String>, List<String>>> schedulePackageValidation(
@@ skipping 427 matching lines @@
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }