Add package-config tests where test is running in Isolate.spawn-isolates.

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";
 
 main() async {
   asyncStart();
 
-  // The `test` function can generate file or http resources.
-  // It replaces "%file/" with URI of the root directory of generated files and
-  // "%http/" with the URI of the HTTP server's root in appropriate contexts
-  // (all file contents and parameters).
-
-  // With no specified resolutiuon and no implicit .packages or packages/
-  // available, nothing can be resolved and the package can't be imported.
-  await test("file: no resolution",
-    "%file/main.dart",
-    file: {"main": testMain},
-    expect: {"foo.x": null});
-
-  // An HTTP script with no ".packages" file assumes a "packages" dir.
-  // All packages are resolved relative to that dir, whether it exists or not.
-  await test("http: no resolution", "%http/main.dart",
-    http: {"main": testMain},
-    expect: {
-      "iroot": "%http/packages/",
-      // "foo": null,
-      "foo/": "%http/packages/foo/",
-      "foo/bar": "%http/packages/foo/bar",
-      "foo.x": null,
-    });
-
-  // A number of tests which behave similarly whether run as local files or
-  // over HTTP.
-  for (var scheme in ["file", "http"]) {
-
-    /// Run a test in the current scheme.
-    ///
-    /// The files are served either through HTTP or in a local directory.
-    /// Use "%$scheme/" to refer to the root of the served files.
-    testScheme(name, main, {expect, files, args, root, config}) {
-      return test("$scheme: $name", main, expect: expect,
-        root: root, config: config, args: args,
-        file: scheme == "file" ? files : null,
-        http: scheme == "http" ? files : null);
+  Future runTests(test) async {

[floitsch, 2016/05/27 14:26:50]

Move that function out. Should make the diff better.

+    // The `test` function can generate file or http resources.
+    // It replaces "%file/" with URI of the root directory of generated files and

[floitsch, 2016/05/27 14:26:50]

Long line.

+    // "%http/" with the URI of the HTTP server's root in appropriate contexts
+    // (all file contents and parameters).
+
+    // With no specified resolutiuon and no implicit .packages or packages/
+    // available, nothing can be resolved and the package can't be imported.
+    await test("file: no resolution",
+      "%file/main.dart",
+      file: {"main": testMain},
+      expect: {"foo.x": null});
+
+    // An HTTP script with no ".packages" file assumes a "packages" dir.
+    // All packages are resolved relative to that dir, whether it exists or not.
+    await test("http: no resolution", "%http/main.dart",
+      http: {"main": testMain},
+      expect: {
+        "iroot": "%http/packages/",
+        // "foo": null,
+        "foo/": "%http/packages/foo/",
+        "foo/bar": "%http/packages/foo/bar",
+        "foo.x": null,
+      });
+
+    // A number of tests which behave similarly whether run as local files or
+    // over HTTP.
+    for (var scheme in ["file", "http"]) {
+
+      /// Run a test in the current scheme.
+      ///
+      /// The files are served either through HTTP or in a local directory.
+      /// Use "%$scheme/" to refer to the root of the served files.
+      testScheme(name, main, {expect, files, args, root, config}) {
+        return test("$scheme: $name", main, expect: expect,
+          root: root, config: config, args: args,
+          file: scheme == "file" ? files : null,
+          http: scheme == "http" ? files : null);
+      }
+
+      {
+        var files = {"main": testMain, "packages": fooPackage};
+        // Expect implicitly detected package dir.
+        await testScheme("implicit packages dir","%$scheme/main.dart",
+          files: files,
+          expect: {
+            "iroot": "%$scheme/packages/",
+            // "foo": null,
+            "foo/": "%$scheme/packages/foo/",
+            "foo/bar": "%$scheme/packages/foo/bar",
+          });
+      }
+
+      {
+        var files = {"sub": {"main": testMain, "packages": fooPackage},
+                     ".packages": ""};
+        // Expect implicitly detected package dir.
+        // Should not detect the .packages file in parent directory.
+        // That file is empty, so if it is used, the system cannot resolve "foo".
+        await testScheme("implicit packages dir 2", "%$scheme/sub/main.dart",
+          files: files,
+          expect: {
+            "iroot": "%$scheme/sub/packages/",
+            // "foo": null,
+            "foo/": "%$scheme/sub/packages/foo/",
+            "foo/bar": "%$scheme/sub/packages/foo/bar",
+          });
+      }
+
+      {
+        var files = {"main": testMain,
+                     ".packages": "foo:pkgs/foo/",
+                     "pkgs": fooPackage};
+        await testScheme("implicit .packages file", "%$scheme/main.dart",
+          files: files,
+          expect: {
+            "iconf": "%$scheme/.packages",
+            // "foo": null,
+            "foo/": "%$scheme/pkgs/foo/",
+            "foo/bar": "%$scheme/pkgs/foo/bar",
+          });
+      }
+
+      {
+        var files = {"main": testMain,
+                     ".packages": "foo:packages/foo/",
+                     "packages": fooPackage,
+                     "pkgs": fooPackage};
+        await testScheme("explicit package root, no slash", "%$scheme/main.dart",
+          files: files,
+          root: "%$scheme/pkgs",
+          expect: {
+            "proot": "%$scheme/pkgs/",
+            "iroot": "%$scheme/pkgs/",
+            // "foo": null,
+            "foo/": "%$scheme/pkgs/foo/",
+            "foo/bar": "%$scheme/pkgs/foo/bar",
+          });
+      }
+
+      {
+        var files = {"main": testMain,
+                     ".packages": "foo:packages/foo/",
+                     "packages": fooPackage,
+                     "pkgs": fooPackage};
+        await testScheme("explicit package root, slash", "%$scheme/main.dart",
+          files: files,
+          root: "%$scheme/pkgs",
+          expect: {
+            "proot": "%$scheme/pkgs/",
+            "iroot": "%$scheme/pkgs/",
+            // "foo": null,
+            "foo/": "%$scheme/pkgs/foo/",
+            "foo/bar": "%$scheme/pkgs/foo/bar",
+          });
+      }
+
+      {
+        var files = {"main": testMain,
+                     ".packages": "foo:packages/foo/",
+                     "packages": fooPackage,
+                     ".pkgs": "foo:pkgs/foo/",
+                     "pkgs": fooPackage};
+        await testScheme("explicit package config file", "%$scheme/main.dart",
+          files: files,
+          config: "%$scheme/.pkgs",
+          expect: {
+            "pconf": "%$scheme/.pkgs",
+            "iconf": "%$scheme/.pkgs",
+            // "foo": null,
+            "foo/": "%$scheme/pkgs/foo/",
+            "foo/bar": "%$scheme/pkgs/foo/bar",
+          });
+      }
+
+      {
+        /// The package config can be specified as a data: URI.
+        /// (In that case, relative URI references in the config file won't work).
+        var files = {"main": testMain,
+                     ".packages": "foo:packages/foo/",
+                     "packages": fooPackage,
+                     "pkgs": fooPackage};
+        var dataUri = "data:,foo:%$scheme/pkgs/foo/\n";
+        await testScheme("explicit data: config file", "%$scheme/main.dart",
+          files: files,
+          config: dataUri,
+          expect: {
+            "pconf": dataUri,
+            "iconf": dataUri,
+            // "foo": null,
+            "foo/": "%$scheme/pkgs/foo/",
+            "foo/bar": "%$scheme/pkgs/foo/bar",
+          });
+      }
     }
 
     {
-      var files = {"main": testMain, "packages": fooPackage};
-      // Expect implicitly detected package dir.
-      await testScheme("implicit packages dir","%$scheme/main.dart",
-        files: files,
+      // With a file: URI, the lookup checks for a .packages file in superdirs
+      // when it fails to find a ,packages file or packages/ directory next to
+      // the entry point.
+      var files = {"sub": { "main": testMain },
+                   ".packages": "foo:pkgs/foo/",
+                   "pkgs": fooPackage};
+      await test("file: implicit .packages file in ..", "%file/sub/main.dart",
+        file: files,
         expect: {
-          "iroot": "%$scheme/packages/",
+          "iconf": "%file/.packages",
           // "foo": null,
-          "foo/": "%$scheme/packages/foo/",
-          "foo/bar": "%$scheme/packages/foo/bar",
+          "foo/": "%file/pkgs/foo/",
+          "foo/bar": "%file/pkgs/foo/bar",
         });
     }
 
     {
-      var files = {"sub": {"main": testMain, "packages": fooPackage},
-                   ".packages": ""};
-      // Expect implicitly detected package dir.
-      // Should not detect the .packages file in parent directory.
-      // That file is empty, so if it is used, the system cannot resolve "foo".
-      await testScheme("implicit packages dir 2", "%$scheme/sub/main.dart",
-        files: files,
-        expect: {
-          "iroot": "%$scheme/sub/packages/",
-          // "foo": null,
-          "foo/": "%$scheme/sub/packages/foo/",
-          "foo/bar": "%$scheme/sub/packages/foo/bar",
-        });
-    }
-
-    {
-      var files = {"main": testMain,
+      // With a non-file: URI, the lookup assumes a packges/ dir.
+      // The absence of a .packages file next to the entry point means
+      // that the resolution assumes a packages directory, whether it exists or
+      // not. It should not find the .packages file in the parent directory.
+      var files = {"sub": { "main": testMain },
                    ".packages": "foo:pkgs/foo/",
                    "pkgs": fooPackage};
-      await testScheme("implicit .packages file", "%$scheme/main.dart",
-        files: files,
+      await test("http: implicit packages dir", "%http/sub/main.dart",
+        http: files,
         expect: {
-          "iconf": "%$scheme/.packages",
+          "iroot": "%http/sub/packages/",
           // "foo": null,
-          "foo/": "%$scheme/pkgs/foo/",
-          "foo/bar": "%$scheme/pkgs/foo/bar",
-        });
-    }
-
-    {
-      var files = {"main": testMain,
-                   ".packages": "foo:packages/foo/",
-                   "packages": fooPackage,
-                   "pkgs": fooPackage};
-      await testScheme("explicit package root, no slash", "%$scheme/main.dart",
-        files: files,
-        root: "%$scheme/pkgs",
-        expect: {
-          "proot": "%$scheme/pkgs/",
-          "iroot": "%$scheme/pkgs/",
-          // "foo": null,
-          "foo/": "%$scheme/pkgs/foo/",
-          "foo/bar": "%$scheme/pkgs/foo/bar",
-        });
-    }
-
-    {
-      var files = {"main": testMain,
-                   ".packages": "foo:packages/foo/",
-                   "packages": fooPackage,
-                   "pkgs": fooPackage};
-      await testScheme("explicit package root, slash", "%$scheme/main.dart",
-        files: files,
-        root: "%$scheme/pkgs",
-        expect: {
-          "proot": "%$scheme/pkgs/",
-          "iroot": "%$scheme/pkgs/",
-          // "foo": null,
-          "foo/": "%$scheme/pkgs/foo/",
-          "foo/bar": "%$scheme/pkgs/foo/bar",
-        });
-    }
-
-    {
-      var files = {"main": testMain,
-                   ".packages": "foo:packages/foo/",
-                   "packages": fooPackage,
-                   ".pkgs": "foo:pkgs/foo/",
-                   "pkgs": fooPackage};
-      await testScheme("explicit package config file", "%$scheme/main.dart",
-        files: files,
-        config: "%$scheme/.pkgs",
-        expect: {
-          "pconf": "%$scheme/.pkgs",
-          "iconf": "%$scheme/.pkgs",
-          // "foo": null,
-          "foo/": "%$scheme/pkgs/foo/",
-          "foo/bar": "%$scheme/pkgs/foo/bar",
-        });
-    }
-
-    {
-      /// The package config can be specified as a data: URI.
-      /// (In that case, relative URI references in the config file won't work).
-      var files = {"main": testMain,
-                   ".packages": "foo:packages/foo/",
-                   "packages": fooPackage,
-                   "pkgs": fooPackage};
-      var dataUri = "data:,foo:%$scheme/pkgs/foo/\n";
-      await testScheme("explicit data: config file", "%$scheme/main.dart",
-        files: files,
-        config: dataUri,
-        expect: {
-          "pconf": dataUri,
-          "iconf": dataUri,
-          // "foo": null,
-          "foo/": "%$scheme/pkgs/foo/",
-          "foo/bar": "%$scheme/pkgs/foo/bar",
+          "foo/": "%http/sub/packages/foo/",
+          "foo/bar": "%http/sub/packages/foo/bar",
+          "foo.x": null,
         });
     }
   }
 
-  {
-    // With a file: URI, the lookup checks for a .packages file in superdirs
-    // when it fails to find a ,packages file or packages/ directory next to
-    // the entry point.
-    var files = {"sub": { "main": testMain },
-                 ".packages": "foo:pkgs/foo/",
-                 "pkgs": fooPackage};
-    await test("file: implicit .packages file in ..", "%file/sub/main.dart",
-      file: files,
-      expect: {
-        "iconf": "%file/.packages",
-        // "foo": null,
-        "foo/": "%file/pkgs/foo/",
-        "foo/bar": "%file/pkgs/foo/bar",
-      });
-  }
-
-  {
-    // With a non-file: URI, the lookup assumes a packges/ dir.
-    // The absence of a .packages file next to the entry point means
-    // that the resolution assumes a packages directory, whether it exists or
-    // not. It should not find the .packages file in the parent directory.
-    var files = {"sub": { "main": testMain },
-                 ".packages": "foo:pkgs/foo/",
-                 "pkgs": fooPackage};
-    await test("http: implicit packages dir", "%http/sub/main.dart",
-      http: files,
-      expect: {
-        "iroot": "%http/sub/packages/",
-        // "foo": null,
-        "foo/": "%http/sub/packages/foo/",
-        "foo/bar": "%http/sub/packages/foo/bar",
-        "foo.x": null,
-      });
-  }
-
+  await runTests(test);
+  await runTests(testSpawn(test));
+  await runTests(testSpawn(testSpawn(test)));
 
   if (failingTests.isNotEmpty) {
     print("Errors found in tests:\n  ${failingTests.join("\n  ")}\n");
     exit(255);
   }
   asyncEnd();
 }
 
 // ---------------------------------------------------------
 // Helper functionality.
 
 var failingTests = new Set();
 
 var fileHttpRegexp = new RegExp(r"%(?:file|http)/");
 
+typedef Future Test(String name, String main,
+                    {String root, String config, List<String> args,
+                     Map file, Map http, Map expect});
+
 Future test(String name, String main,
             {String root, String config, List<String> args,
              Map file, Map http, Map expect}) async {
   // Default values that are easily recognized in output.
   String fileRoot = "<no files configured>";
   String httpRoot = "<no http server configured>";
 
   /// Replaces markers `%file/` and `%http/` with the actual locations.
   ///
   /// Accepts a `null` [source] and returns `null` again.
@@ skipping 48 matching lines @@
     // Unexpected error calling runDart or parsing the result.
     // Report it and continue.
     print("ERROR running $name: $e\n$s");
     failingTests.add(name);
   } finally {
     if (https != null) await https.close();
     if (tmpDir != null) tmpDir.deleteSync(recursive: true);
   }
 }
 
+Test testSpawn(Test test) =>
+    (String name, String main,
+     {String root, String config, List<String> args,
+      Map file, Map http, Map expect}) {
+      // Add spawnMain file next to main file.
+      var spawnMainName = "_spawnMain${tmpNameCounter++}";
+      var parts = main.split('/').toList();
+      var files;
+      if (parts[0] == "%file") {
+        files = file;
+      } else {
+        assert(parts[0] == "%http");
+        files = http;
+      }
+      for (var i = 1; i < parts.length - 1; i++) {
+        files = files[parts[i]];
+      }
+      files[spawnMainName] = spawnMain.replaceAll("%main", main);
+      parts[parts.length - 1] = "$spawnMainName.dart";
+
+      return test("spawn: $name", parts.join("/"),
+                          root: root, config: config, args: args,
+                          file: file, http: http, expect: expect);
+    };
+
 
 /// Test that the output of running testMain matches the expectations.
 ///
 /// The output is a string which is parse as a JSON literal.
 /// The resulting map is always mapping strings to strings, or possibly `null`.
 /// The expectations can have non-string values other than null,
 /// they are `toString`'ed  before being compared (so the caller can use a URI
 /// or a File/Directory directly as an expectation).
 void match(Map actuals, Map expectations, String fixPaths(String expectation),
            String name) {
@@ skipping 54 matching lines @@
 const String spawnUriMain = r"""
 import "dart:isolate";
 main(args) async {
   Uri target = Uri.parse(args[0]);
   Uri conf = args.length > 1 && args[1].isNotEmpty ? Uri.parse(args[1]) : null;
   Uri root = args.length > 2 && args[2].isNotEmpty ? Uri.parse(args[2]) : null;
   var restArgs = args.skip(3).toList();
   var isolate = await Isolate.spawnUri(target, restArgs,
       packageRoot: root, packageConfig: conf, paused: true);
   // Wait for isolate to exit before exiting the main isolate.
-  var done = new RawReceivePort();
-  done.handler = (_) { done.close(); };
-  isolate.addExitHandler(done.sendPort);
+  var port = new RawReceivePort();
+  port.handler = (res) async {
+    port.close();  // Close on done or first error.
+    if (res != null) {
+      await new Future.error(res[0], new Stacktrace.fromString(res[1]));
+    }
+  };
+  isolate.addOnExitListener(port.sendPort);
+  isolate.addErrorListener(port.sendPort);
   isolate.resume(isolate.pauseCapability);
 }
 """;
 
 /// Script that spawns a new Isolate using Isolate.spawn.
 const String spawnMain = r"""
+import "dart:async";
 import "dart:isolate";
-import "testmain.dart" as test;
-main() async {
+import "%main" as test;
+main([_]) async {
   var isolate = await Isolate.spawn(test.main, [], paused: true);
   // Wait for isolate to exit before exiting the main isolate.
-  var done = new RawReceivePort();
-  done.handler = (_) { done.close(); };
-  isolate.addExitHandler(done.sendPort);
+  var port = new RawReceivePort();
+  port.handler = (res) async {
+    port.close();  // Close on port or first error.
+    if (res != null) {
+      await new Future.error(res[0], new Stacktrace.fromString(res[1]));
+    }
+  };
+  isolate.addOnExitListener(port.sendPort);
+  isolate.addErrorListener(port.sendPort);
   isolate.resume(isolate.pauseCapability);
 }
 """;
 
 /// A package directory containing only one package, "foo", with one file.
 const Map fooPackage = const { "foo": const { "foo": "var x = 'qux';" }};
 
 /// Runs the Dart executable with the provided parameters.
 ///
 /// Captures and returns the output.
 Future<String> runDart(String script,
                        {String root, String config,
                         Iterable<String> scriptArgs}) async {
+  var checked = false;
+  assert((checked = true));

[floitsch, 2016/05/27 14:26:50]

Add a comment.

   // TODO: Find a way to change CWD before running script.
   var executable = Platform.executable;
   var args = [];
-  if (root != null) args..add("-p")..add(root);
-  if (config != null) args..add("--packages=$config");
+  if (checked) args.add("--checked");
+  if (root != null) args.add("--package-root=$root");
+  if (config != null) args.add("--packages=$config");
   args.add(script);
   if (scriptArgs != null) {
     args.addAll(scriptArgs);
   }
   return Process.run(executable, args).then((results) {
     if (results.exitCode != 0) {
       throw results.stderr;
     }
     return results.stdout;
   });
@@ skipping 77 matching lines @@
           }
         }
         request.response..statusCode = HttpStatus.NOT_FOUND
                         ..close();
       });
 }
 
 // Counter used to avoid reusing temporary directory names.
 // Some platforms are timer based, and creating two temp-dirs withing a short
 // duration may cause a collision.
-int tmpDirCounter = 0;
+int tmpNameCounter = 0;
 
 Directory createTempDir() {
-  return Directory.systemTemp.createTempSync("pftest-${tmpDirCounter++}-");
+  return Directory.systemTemp.createTempSync("pftest-${tmpNameCounter++}-");
 }