Add more tests

lib/discovery.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.
 
 library package_config.discovery;
 
 import "dart:async";
 import "dart:io" show Directory, File, FileSystemEntity;
 import "package:path/path.dart" as path;
 import "package:http/http.dart" as http;
@@ skipping 26 matching lines @@
 /// It's called to load the `.packages` file for any unsupported scheme.
 /// It must return the *contents* of the file identified by the URI it's given,
 /// which should be a UTF-8 encoded `.packages` file, and must return an
 /// error future if loading fails for any reason.
 Future<Packages> findPackages(
     Uri baseUri,
     {Future<List<int>> loader(Uri unsupportedUri)}) {
   if (baseUri.scheme == "file") {
     return new Future<Packages>.sync(() => findPackagesFromFile(baseUri));
   } else if (baseUri.scheme == "http" || baseUri.scheme == "https") {
-    return findPackagesFromNonFile(baseUri, _httpGet);
+    return findPackagesFromNonFile(baseUri, loader: _httpGet);
   } else if (loader != null) {
-    return findPackagesFromNonFile(baseUri, loader);
+    return findPackagesFromNonFile(baseUri, loader: loader);
   } else {
     return new Future<Packages>.value(Packages.noPackages);
   }
 }
 
 /// Find the location of the package resolution file/directory for a Dart file.
 ///
 /// Checks for a `.packages` file in the [workingDirectory].
 /// If not found, checks for a `packages` directory in the same directory.
 /// If still not found, starts checking parent directories for
@@ skipping 71 matching lines @@
 /// This function first tries to locate a `.packages` file in the [nonFileUri]
 /// directory. If that is not found, it instead assumes a `packages/` directory
 /// in the same place.
 ///
 /// By default, this function only works for `http:` and `https:` URIs.
 /// To support other schemes, a loader must be provided, which is used to
 /// try to load the `.packages` file. The loader should return the contents
 /// of the requestsed `.packages` file as bytes, which will be assumed to be
 /// UTF-8 encoded.
 Future<Packages> findPackagesFromNonFile(Uri nonFileUri,
-                                         [Future<List<int>> loader(Uri name)]) {
+                                         {Future<List<int>> loader(Uri name)}) {
   if (loader == null) loader = _httpGet;
   Uri packagesFileUri = nonFileUri.resolve(".packages");
   return loader(packagesFileUri).then((List<int> fileBytes) {
     Map<String, Uri> map = pkgfile.parse(fileBytes, packagesFileUri);
     return new MapPackages(map);
   }, onError: (_) {
     // Didn't manage to load ".packages". Assume a "packages/" directory.
     Uri packagesDirectoryUri = nonFileUri.resolve("packages/");
     return new NonFilePackagesDirectoryPackages(packagesDirectoryUri);
   });
 }
 
 /// Fetches a file using the http library.
 Future<List<int>> _httpGet(Uri uri) {
   return http.get(uri).then((http.Response response) {
     if (response.statusCode == 200) return response.bodyBytes;
     throw 0;  // The error message isn't being used for anything.
   });
 }