Roll to pickup pool changes

packages/package_config/test/discovery_test.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_test;
 
 import "dart:async";
 import "dart:io";
 import "package:test/test.dart";
 import "package:package_config/packages.dart";
@@ skipping 23 matching lines @@
   expect(resolver, isNotNull);
   expect(resolver.resolve(pkg("foo", "bar/baz")),
       equals(location.resolve("packages/foo/bar/baz")));
   expect(resolver.resolve(pkg("bar", "baz/qux")),
       equals(location.resolve("packages/bar/baz/qux")));
   expect(resolver.resolve(pkg("baz", "qux/foo")),
       equals(location.resolve("packages/baz/qux/foo")));
   if (location.scheme == "file") {
     expect(resolver.packages, unorderedEquals(["foo", "bar", "baz"]));
   } else {
-    expect(() => resolver.packages, throws);
+    expect(() => resolver.packages, throwsUnsupportedError);
   }
 }
 
 Uri pkg(String packageName, String packagePath) {
   var path;
   if (packagePath.startsWith('/')) {
     path = "$packageName$packagePath";
   } else {
     path = "$packageName/$packagePath";
   }
@@ skipping 107 matching lines @@
   });
 
   test(".packages w/ loader", () async {
     Uri location = Uri.parse("krutch://example.com/path/");
     Future<List<int>> loader(Uri file) async {
       if (file.path.endsWith(".packages")) {
         return packagesFile.codeUnits;
       }
       throw "not found";
     }
+
     // A non-file: location with no .packages or packages/:
     // Assumes a packages dir exists, and resolves relative to that.
     Packages resolver;
     resolver = await findPackages(location, loader: loader);
     validatePackagesFile(resolver, location);
     resolver =
         await findPackages(location.resolve("script.dart"), loader: loader);
     validatePackagesFile(resolver, location);
     resolver = await findPackagesFromNonFile(location, loader: loader);
     validatePackagesFile(resolver, location);
     resolver = await findPackagesFromNonFile(location.resolve("script.dart"),
         loader: loader);
     validatePackagesFile(resolver, location);
   });
 
   test("no packages w/ loader", () async {
     Uri location = Uri.parse("krutch://example.com/path/");
     Future<List<int>> loader(Uri file) async {
       throw "not found";
     }
+
     // A non-file: location with no .packages or packages/:
     // Assumes a packages dir exists, and resolves relative to that.
     Packages resolver;
     resolver = await findPackages(location, loader: loader);
     validatePackagesDir(resolver, location);
     resolver =
         await findPackages(location.resolve("script.dart"), loader: loader);
     validatePackagesDir(resolver, location);
     resolver = await findPackagesFromNonFile(location, loader: loader);
     validatePackagesDir(resolver, location);
@@ skipping 19 matching lines @@
 
   test("loadPackagesFile w/ loader", () async {
     Future<List<int>> loader(Uri uri) async => packagesFile.codeUnits;
     Uri file = Uri.parse("krutz://example.com/.packages");
     Packages resolver = await loadPackagesFile(file, loader: loader);
     validatePackagesFile(resolver, file);
   });
 
   generalTest("loadPackagesFile not found", {}, (Uri directory) async {
     Uri file = directory.resolve(".packages");
-    expect(loadPackagesFile(file), throws);
+    expect(
+        loadPackagesFile(file),
+        throwsA(anyOf(new isInstanceOf<FileSystemException>(),
+            new isInstanceOf<HttpException>())));
   });
 
   generalTest("loadPackagesFile syntax error", {".packages": "syntax error"},
       (Uri directory) async {
     Uri file = directory.resolve(".packages");
-    expect(loadPackagesFile(file), throws);
+    expect(loadPackagesFile(file), throwsFormatException);
   });
 
   generalTest("getPackagesDir", {
     "packages": {"foo": {}, "bar": {}, "baz": {}}
   }, (Uri directory) async {
     Uri packages = directory.resolve("packages/");
     Packages resolver = getPackagesDirectory(packages);
     Uri resolved = resolver.resolve(pkg("foo", "flip/flop"));
     expect(resolved, packages.resolve("foo/flip/flop"));
   });
@@ skipping 65 matching lines @@
     if (content is Map) {
       Directory subDir = new Directory(path.join(target.path, name));
       subDir.createSync();
       _createFiles(subDir, content);
     } else {
       File file = new File(path.join(target.path, name));
       file.writeAsStringSync(content, flush: true);
     }
   });
 }