Add tests for resolving missing packages, relative and absolute URIs.

tests/standalone/packages_file_test.dart

 // Copyright (c) 2016, 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:convert" show JSON;
 import "package:path/path.dart" as p;
 import "package:async_helper/async_helper.dart";
 
@@ skipping 202 matching lines @@
 //
 // The combinations covers most configurations of implicit and explicit
 // package configurations over both file: and http: file sources.
 // It also specifies the expected values of the following for a VM
 // run in that configuration.
 //
 // * `Process.packageRoot`
 // * `Process.packageConfig`
 // * `Isolate.packageRoot`
 // * `Isolate.packageRoot`
-// * `Isolate.resolvePacakgeUri` of various inputs.
+// * `Isolate.resolvePackageUri` of various inputs.
 // * A variable defined in a library loaded using a `package:` URI.
 //
 // The configurations all have URIs as `root`, `config` and `mainFile` strings,
 // have empty argument lists and `mainFile` points to the the `main.dart` file.
 void createConfigurations() {
   add(String description, String mainDir, {String root, String config,
       Map file, Map http, Map expect}) {
     var id = freshName("conf");
 
     file ??= {};
@@ skipping 51 matching lines @@
     fixPaths(file);
     fixPaths(http);
     // These expectations are default. If not overridden the value will be
     // expected to be null. That is, you can't avoid testing the actual
     // value of these, you can only change what value to expect.
     // For values not included here (commented out), the result is not tested
     // unless a value (maybe null) is provided.
     fixPaths(expect);
 
     expect = {
-      "pconf":   null,
-      "proot":   null,
-      "iconf":   null,
-      "iroot":   null,
-      // "foo":   null,
-      "foo/":    null,
-      "foo/bar": null,
-      "foo.x":  "qux",
+      "pconf":    null,
+      "proot":    null,
+      "iconf":    null,
+      "iroot":    null,
+      // "foo":     null,
+      "foo/":     null,
+      "foo/bar":  null,
+      "foo.x":    "qux",
+      "bar/bar":  null,
+      "relative": "relative/path",
+      "nonpkg":   "http://example.org/file"
     }..addAll(expect ?? const {});
 
     // Add http files to the http server.
     if (http.isNotEmpty) {
       httpFiles[id] = http;
     }
     // Add file files to the file system.
     if (file.isNotEmpty) {
       createFiles(fileRoot, id, file);
     }
@@ skipping 33 matching lines @@
       addScheme("no resolution",
         "%$scheme/",
         files: {},
         expect: (scheme == "file") ? {
           "foo.x": null
         } : {
           "iroot": "%http/packages/",
           "foo/": "%http/packages/foo/",
           "foo/bar": "%http/packages/foo/bar",
           "foo.x": null,
+          "bar/bar": "%http/packages/bar/bar",
         });
     }
 
     {
       // No parameters, no .packages files,
       // packages/ dir exists and is detected.
       var files = {"packages": fooPackage};
       addScheme("implicit packages dir","%$scheme/",
         files: files,
         expect: {
           "iroot": "%$scheme/packages/",
           "foo/": "%$scheme/packages/foo/",
           "foo/bar": "%$scheme/packages/foo/bar",
+          "bar/bar": "%$scheme/packages/bar/bar",
         });
     }
 
     {
       // No parameters, no .packages files in current dir, but one in parent,
       // packages/ dir exists and is used.
       //
       // Should not detect the .packages file in parent directory.
       // That file is empty, so if it is used, the system cannot resolve "foo".
       var files = {"sub": {"packages": fooPackage},
                    ".packages": ""};
       addScheme("implicit packages dir overrides parent .packages",
         "%$scheme/sub/",
         files: files,
         expect: {
           "iroot": "%$scheme/sub/packages/",
           "foo/": "%$scheme/sub/packages/foo/",
           "foo/bar": "%$scheme/sub/packages/foo/bar",
           // "foo.x": "qux",  // Blocked by issue http://dartbug.com/26482
+          "bar/bar": "%$scheme/sub/packages/bar/bar",
         });
     }
 
     {
       // No parameters, a .packages file next to entry is found and used.
       // A packages/ directory is ignored.
       var files = {".packages": "foo:pkgs/foo/",
                    "packages": {},
                    "pkgs": fooPackage};
       addScheme("implicit .packages file", "%$scheme/",
@@ skipping 16 matching lines @@
         files: files,
         expect: (scheme == "file") ? {
           "iconf": "%file/.packages",
           "foo/": "%file/pkgs/foo/",
           "foo/bar": "%file/pkgs/foo/bar",
         } : {
           "iroot": "%http/sub/packages/",
           "foo/": "%http/sub/packages/foo/",
           "foo/bar": "%http/sub/packages/foo/bar",
           "foo.x": null,
+          "bar/bar": "%http/sub/packages/bar/bar",
         });
     }
 
     {
       // Specified package root that doesn't exist.
       // Ignores existing .packages file and packages/ dir.
       addScheme("explicit root not there",
         "%$scheme/",
         files: {"packages": fooPackage,
                 ".packages": "foo:%$scheme/packages/"},
         root: "%$scheme/notthere/",
         expect: {
           "proot": "%$scheme/notthere/",
           "iroot": "%$scheme/notthere/",
           "foo/": "%$scheme/notthere/foo/",
           "foo/bar": "%$scheme/notthere/foo/bar",
           "foo.x": null,
+          "bar/bar": "%$scheme/notthere/bar/bar",
         });
     }
 
     {
       // Specified package config that doesn't exist.
       // Ignores existing .packages file and packages/ dir.
       addScheme("explicit config not there",
         "%$scheme/",
         files: {".packages": "foo:packages/foo/",
                 "packages": fooPackage},
@@ skipping 14 matching lines @@
                    "packages": {},
                    "pkgs": fooPackage};
       addScheme("explicit package root, no slash", "%$scheme/",
         files: files,
         root: "%$scheme/pkgs",
         expect: {
           "proot": "%$scheme/pkgs/",
           "iroot": "%$scheme/pkgs/",
           "foo/": "%$scheme/pkgs/foo/",
           "foo/bar": "%$scheme/pkgs/foo/bar",
+          "bar/bar": "%$scheme/pkgs/bar/bar",
         });
     }
 
     {
       // Specified package root with trailing slash.
       var files = {".packages": "foo:packages/foo/",
                    "packages": {},
                    "pkgs": fooPackage};
       addScheme("explicit package root, slash", "%$scheme/",
         files: files,
         root: "%$scheme/pkgs",
         expect: {
           "proot": "%$scheme/pkgs/",
           "iroot": "%$scheme/pkgs/",
           "foo/": "%$scheme/pkgs/foo/",
           "foo/bar": "%$scheme/pkgs/foo/bar",
+          "bar/bar": "%$scheme/pkgs/bar/bar",
         });
     }
 
     {
       // Specified package config.
       var files = {".packages": "foo:packages/foo/",
                    "packages": {},
                    ".pkgs": "foo:pkgs/foo/",
                    "pkgs": fooPackage};
       addScheme("explicit package config file", "%$scheme/",
@@ skipping 39 matching lines @@
         (entryScheme == "file" ? files : https)["main"] = testMain;
         (pkgScheme == "file" ? files : https)["pkgs"] = fooPackage;
         add("$pkgScheme pkg/$entryScheme main", "%$entryScheme/",
           file: files, http: https,
           root: "%$pkgScheme/pkgs/",
           expect: {
             "proot": "%$pkgScheme/pkgs/",
             "iroot": "%$pkgScheme/pkgs/",
             "foo/": "%$pkgScheme/pkgs/foo/",
             "foo/bar": "%$pkgScheme/pkgs/foo/bar",
+            "bar/bar": "%$pkgScheme/pkgs/bar/bar",
             "foo.x": "qux",
           });
       }
       // Package config. The configuration file may also be on either source.
       for (var configScheme in const ["file", "http"]) {
         // Don't do the boring stuff!
         if (entryScheme == configScheme && entryScheme == pkgScheme) continue;
         // Package config, packages and entry point not all on same scheme.
         var files = {};
         var https = {};
@@ skipping 83 matching lines @@
   String platformRoot = await Platform.packageRoot;
   String platformConfig = await Platform.packageConfig;
   Directory cwd = Directory.current;
   Uri script = Platform.script;
   Uri isolateRoot = await Isolate.packageRoot;
   Uri isolateConfig = await Isolate.packageConfig;
   Uri base = Uri.base;
   Uri res1 = await Isolate.resolvePackageUri(Uri.parse("package:foo"));
   Uri res2 = await Isolate.resolvePackageUri(Uri.parse("package:foo/"));
   Uri res3 = await Isolate.resolvePackageUri(Uri.parse("package:foo/bar"));
+  Uri res4 = await Isolate.resolvePackageUri(Uri.parse("package:bar/bar"));
+  Uri res5 = await Isolate.resolvePackageUri(Uri.parse("relative/path"));
+  Uri res6 = await Isolate.resolvePackageUri(
+      Uri.parse("http://example.org/file"));
   String fooX = await foo
     .loadLibrary()
     .timeout(const Duration(seconds: 1))
     .then((_) => foo.x, onError: (_) => null);
   print(JSON.encode({
     "cwd": cwd.path,
     "base": base?.toString(),
     "script": script?.toString(),
     "proot": platformRoot,
     "pconf": platformConfig,
     "iroot" : isolateRoot?.toString(),
     "iconf" : isolateConfig?.toString(),
     "foo": res1?.toString(),
     "foo/": res2?.toString(),
     "foo/bar": res3?.toString(),
     "foo.x": fooX?.toString(),
+    "bar/bar": res4?.toString(),
+    "relative": res5?.toString(),
+    "nonpkg": res6?.toString(),
   }));
 }
 """;
 
 /// Script that spawns a new Isolate using Isolate.spawnUri.
 ///
 /// Takes URI of target isolate, package config, package root and
 /// automatic package resolution-flag parameters as command line arguments.
 /// Any further arguments are forwarded to the spawned isolate.
 const String spawnUriMain = """
@@ skipping 287 matching lines @@
 void insertFileAt(Map file, Map http,
                   String path, String name, String content) {
   var parts = path.split('/').toList();
   var dir = (parts[0] == "%file") ? file : http;
   for (var i = 1; i < parts.length - 1; i++) {
     var entry = parts[i];
     dir = dir[entry] ?? (dir[entry] = {});
   }
   dir[name] = content;
 }