Get rid of old redundant methods in io.dart.

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 405 matching lines @@
     return result;
   });
 }
 
 /// Return the name for the package described by [description] and from
 /// [sourceName].
 String _packageName(String sourceName, description) {
   switch (sourceName) {
   case "git":
     var url = description is String ? description : description['url'];
-    return basename(url.replaceFirst(new RegExp(r"(\.git)?/?$"), ""));
+    // TODO(rnystrom): Using path.basename on a URL is hacky. If we add URL
+    // support to pkg/path, should use an explicit builder for that.
+    return path.basename(url.replaceFirst(new RegExp(r"(\.git)?/?$"), ""));
   case "hosted":
     if (description is String) return description;
     return description['name'];
   case "sdk":
     return description;
   default:
     return description;
   }
 }
 
 /// The path of the package cache directory used for tests. Relative to the
 /// sandbox directory.
 final String cachePath = "cache";
 
 /// The path of the mock SDK directory used for tests. Relative to the sandbox
 /// directory.
 final String sdkPath = "sdk";
 
 /// The path of the mock app directory used for tests. Relative to the sandbox
 /// directory.
 final String appPath = "myapp";
 
 /// The path of the packages directory in the mock app used for tests. Relative
 /// to the sandbox directory.
 final String packagesPath = "$appPath/packages";
 
 /// The type for callbacks that will be fired during [schedulePub]. Takes the
 /// sandbox directory as a parameter.
-typedef Future _ScheduledEvent(Directory parentDir);
+typedef Future _ScheduledEvent(String parentDir);
 
 /// The list of events that are scheduled to run as part of the test case.
 List<_ScheduledEvent> _scheduled;
 
 /// The list of events that are scheduled to run after the test case, even if
 /// it failed.
 List<_ScheduledEvent> _scheduledCleanup;
 
 /// The list of events that are scheduled to run after the test case only if it
 /// failed.
@@ skipping 54 matching lines @@
       // advance to the next test and run it.
       registerException(e.error, e.stackTrace);
     });
   });
 }
 
 /// Get the path to the root "util/test/pub" directory containing the pub
 /// tests.
 String get testDirectory {
   var dir = new Options().script;
-  while (basename(dir) != 'pub') dir = dirname(dir);
+  while (path.basename(dir) != 'pub') dir = path.dirname(dir);
 
-  return getFullPath(dir);
+  return path.absolute(dir);
 }
 
 /// Schedules a call to the Pub command-line utility. Runs Pub with [args] and
 /// validates that its results match [output], [error], and [exitCode].
 void schedulePub({List args, Pattern output, Pattern error,
     Future<Uri> tokenEndpoint, int exitCode: 0}) {
   _schedule((sandboxDir) {
     return _doPub(runProcess, sandboxDir, args, tokenEndpoint).then((result) {
       var failures = [];
 
@@ skipping 57 matching lines @@
   expectLater(pub.nextLine(), equals(""));
 
   pub.writeLine("y");
 }
 
 
 /// Calls [fn] with appropriately modified arguments to run a pub process. [fn]
 /// should have the same signature as [startProcess], except that the returned
 /// [Future] may have a type other than [Process].
 Future _doPub(Function fn, sandboxDir, List args, Future<Uri> tokenEndpoint) {
-  String pathInSandbox(path) => join(getFullPath(sandboxDir), path);
+  String pathInSandbox(String relPath) {
+    return join(path.absolute(sandboxDir), relPath);
+  }
+
   return defer(() {
     ensureDir(pathInSandbox(appPath));
     return Future.wait([
       _awaitObject(args),
       tokenEndpoint == null ? new Future.immediate(null) : tokenEndpoint
     ]);
   }).then((results) {
     var args = results[0];
     var tokenEndpoint = results[1];
     // Find a Dart executable we can use to spawn. Use the same one that was
@@ skipping 49 matching lines @@
 /// Note that this will only affect HTTP requests made via http.dart in the
 /// parent process.
 void useMockClient(MockClient client) {
   var oldInnerClient = httpClient.inner;
   httpClient.inner = client;
   _scheduleCleanup((_) {
     httpClient.inner = oldInnerClient;
   });
 }
 
-Future _runScheduled(Directory parentDir, List<_ScheduledEvent> scheduled) {
+Future _runScheduled(String parentDir, List<_ScheduledEvent> scheduled) {
   if (scheduled == null) return new Future.immediate(null);
   var iterator = scheduled.iterator;
 
   Future runNextEvent(_) {
     if (_abortScheduled || !iterator.moveNext()) {
       _abortScheduled = false;
       scheduled.clear();
       return new Future.immediate(null);
     }
 
@@ skipping 117 matching lines @@
   /// directory.
   // TODO(nweiz): Use implicit closurization once issue 2984 is fixed.
   void scheduleCreate() => _schedule((dir) => this.create(dir));
 
   /// Schedules the file or directory to be deleted recursively.
   void scheduleDelete() => _schedule((dir) => this.delete(dir));
 
   /// Schedules the directory to be validated after Pub is run with
   /// [schedulePub]. The directory will be validated relative to the sandbox
   /// directory.
-  void scheduleValidate() => _schedule((parentDir) => validate(parentDir.path));
+  void scheduleValidate() => _schedule((parentDir) => validate(parentDir));
 
   /// Asserts that the name of the descriptor is a [String] and returns it.
   String get _stringName {
     if (name is String) return name;
     throw 'Pattern $name must be a string.';
   }
 
   /// Validates that at least one file in [dir] matching [name] is valid
   /// according to [validate]. [validate] should throw or complete to an
   /// exception if the input path is invalid.
@@ skipping 772 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);
     });
   });
 }