Use the package_resolver package.

lib/src/util/io.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:async';
 import 'dart:io';
-import 'dart:mirrors';
 
 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 
 import '../backend/operating_system.dart';
-import '../runner/application_exception.dart';
 import '../util/stream_queue.dart';
 import '../utils.dart';
 
 /// The ASCII code for a newline character.
 const _newline = 0xA;
 
 /// The ASCII code for a carriage return character.
 const _carriageReturn = 0xD;
 
 /// The root directory of the Dart SDK.
@@ skipping 21 matching lines @@
 
 /// The root directory below which to nest temporary directories created by the
 /// test runner.
 ///
 /// This is configurable so that the test code can validate that the runner
 /// cleans up after itself fully.
 final _tempDir = Platform.environment.containsKey("_UNITTEST_TEMP_DIR")
     ? Platform.environment["_UNITTEST_TEMP_DIR"]
     : Directory.systemTemp.path;
 
-/// The path to the `lib` directory of the `test` package.
-String libDir({String packageRoot}) {
-  var pathToIo = libraryPath(#test.util.io, packageRoot: packageRoot);
-  return p.dirname(p.dirname(p.dirname(pathToIo)));
-}
-
 // TODO(nweiz): Make this check [stdioType] once that works within "pub run".
 /// Whether "special" strings such as Unicode characters or color escapes are
 /// safe to use.
 ///
 /// On Windows or when not printing to a terminal, only printable ASCII
 /// characters should be used.
 bool get canUseSpecialChars =>
     Platform.operatingSystem != 'windows' && !inTestTests;
 
 /// Creates a temporary directory and returns its path.
@@ skipping 46 matching lines @@
 /// it controls whether the warning header is color; otherwise, it defaults to
 /// [canUseSpecialChars].
 void warn(String message, {bool color}) {
   if (color == null) color = canUseSpecialChars;
   var header = color
       ? "\u001b[33mWarning:\u001b[0m"
       : "Warning:";
   stderr.writeln(wordWrap("$header $message\n"));
 }
 
-/// Returns the package root at [root].
-///
-/// If [override] is passed, that's used. If the package root doesn't exist, an
-/// [ApplicationException] is thrown.
-String packageRootFor(String root, [String override]) {
-  if (root == null) root = p.current;
-  var packageRoot = override == null ? p.join(root, 'packages') : override;
-
-  if (!new Directory(packageRoot).existsSync()) {
-    throw new ApplicationException(
-        "Directory ${p.prettyUri(p.toUri(packageRoot))} does not exist.");
-  }
-
-  return packageRoot;
-}
-
-/// The library name must be globally unique, or the wrong library path may be
-/// returned.
-String libraryPath(Symbol libraryName, {String packageRoot}) {
-  var lib = currentMirrorSystem().findLibrary(libraryName);
-  if (lib.uri.scheme != 'package') return p.fromUri(lib.uri);
-
-  // TODO(nweiz): is there a way to avoid assuming this is being run next to a
-  // packages directory?.
-  if (packageRoot == null) packageRoot = p.absolute('packages');
-  return p.join(packageRoot, p.fromUri(lib.uri.path));
-}
-
 /// Repeatedly finds a probably-unused port on localhost and passes it to
 /// [tryPort] until it binds successfully.
 ///
 /// [tryPort] should return a non-`null` value or a Future completing to a
 /// non-`null` value once it binds successfully. This value will be returned
 /// by [getUnusedPort] in turn.
 ///
 /// This is necessary for ensuring that our port binding isn't flaky for
 /// applications that don't print out the bound port.
 Future/*<T>*/ getUnusedPort/*<T>*/(/*=T*/ tryPort(int port)) {
   var/*=T*/ value;
   return Future.doWhile(() async {
     value = await tryPort(await getUnsafeUnusedPort());
     return value == null;
   }).then((_) => value);
 }
 
 /// Returns a port that is probably, but not definitely, not in use.
 ///
 /// This has a built-in race condition: another process may bind this port at
 /// any time after this call has returned. If at all possible, callers should
 /// use [getUnusedPort] instead.
 Future<int> getUnsafeUnusedPort() async {
   var socket = await RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0);
   var port = socket.port;
   await socket.close();
   return port;
 }