Revert "Format all multitests"

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";
 
 /// Root directory of generated files.
 /// Path contains trailing slash.
 /// Each configuration gets its own sub-directory.
 Directory fileRoot;
-
 /// Shared HTTP server serving the files in [httpFiles].
 /// Each configuration gets its own "sub-dir" entry in `httpFiles`.
 HttpServer httpServer;
-
 /// Directory structure served by HTTP server.
 Map<String, dynamic> httpFiles = {};
-
 /// List of configurations.
 List<Configuration> configurations = [];
-
 /// Collection of failing tests and their failure messages.
 ///
 /// Each test may fail in more than one way.
 var failingTests = <String, List<String>>{};
 
 main() async {
   asyncStart();
   await setUp();
 
   await runTests(); //                         //# 01: ok
   await runTests([spawn]); //                  //# 02: ok
   await runTests([spawn, spawn]); //           //# 03: ok
   await runTests([spawnUriInherit]); //        //# 04: ok
   await runTests([spawnUriInherit, spawn]); // //# 05: ok
   await runTests([spawn, spawnUriInherit]); // //# 06: ok
 
   // Test that spawning a new VM with file paths instead of URIs as arguments
   // gives the same URIs in the internal values.
   await runTests([asPath]); //                 //# 07: ok
 
   // Test that spawnUri can reproduce the behavior of VM command line parameters
   // exactly.
   // (Don't run all configuration combinations in the same test, so
   // unroll the configurations into multiple groups and run each group
   // as its own multitest.
   {
     var groupCount = 8;
-    var groups = new List.generate(8, (_) => []);
+    var groups = new List.generate(8, (_)=>[]);
     for (int i = 0; i < configurations.length; i++) {
       groups[i % groupCount].add(configurations[i]);
     }
     var group = -1;
     group = 0; //                              //# 10: ok
     group = 1; //                              //# 11: ok
     group = 2; //                              //# 12: ok
     group = 3; //                              //# 13: ok
     group = 4; //                              //# 14: ok
     group = 5; //                              //# 15: ok
     group = 6; //                              //# 16: ok
     group = 7; //                              //# 17: ok
     if (group >= 0) {
       for (var other in groups[group]) {
         await runTests([spawnUriOther(other)]);
       }
     }
   }
 
+
   await tearDown();
 
   if (failingTests.isNotEmpty) {
     print("Errors found in tests:");
     failingTests.forEach((test, actual) {
       print("$test:\n  ${actual.join("\n  ")}");
     });
     exit(255);
   }
 
   asyncEnd();
 }
 
 /// Test running the test of the configuration through [Isolate.spawn].
 ///
 /// This should not change the expected results compared to running it
 /// directly.
 Configuration spawn(Configuration conf) {
   return conf.update(
-      description: conf.description + "/spawn",
-      main: "spawnMain",
-      newArgs: [conf.mainType],
-      expect: null);
+    description: conf.description + "/spawn",
+    main: "spawnMain",
+    newArgs: [conf.mainType],
+    expect: null
+  );
 }
 
 /// Tests running a spawnUri on top of the configuration before testing.
 ///
 /// The `spawnUri` call has no explicit root or config parameter, and
 /// shouldn't search for one, so it implicitly inherits the current isolate's
 /// actual root or configuration.
 Configuration spawnUriInherit(Configuration conf) {
   if (conf.expect["iroot"] == null &&
       conf.expect["iconf"] == null &&
       conf.expect["pconf"] != null) {
     // This means that the specified configuration file didn't exist.
     // spawning a new URI to "inherit" that will actually do an automatic
     // package resolution search with results that are unpredictable.
     // That behavior will be tested in a setting where we have more control over
     // the files around the spawned URI.
     return null;
   }
   return conf.update(
-      description: conf.description + "/spawnUri-inherit",
-      main: "spawnUriMain",
-      // encode null parameters as "-". Windows fails if using empty string.
-      newArgs: [
-        conf.mainFile,
-        "-",
-        "-",
-        "false"
-      ],
-      expect: {
-        "proot": conf.expect["iroot"],
-        "pconf": conf.expect["iconf"],
-      });
+    description: conf.description + "/spawnUri-inherit",
+    main: "spawnUriMain",
+    // encode null parameters as "-". Windows fails if using empty string.
+    newArgs: [conf.mainFile, "-", "-", "false"],
+    expect: {
+      "proot": conf.expect["iroot"],
+      "pconf": conf.expect["iconf"],
+    }
+  );
 }
 
 /// Tests running a spawnUri with an explicit configuration different
 /// from the original configuration.
 ///
 /// Duplicates the explicit parameters as arguments to the spawned isolate.
 ConfigurationTransformer spawnUriOther(Configuration other) {
   return (Configuration conf) {
     bool search = (other.config == null) && (other.root == null);
     return conf.update(
-        description: "${conf.description} -spawnUri-> ${other.description}",
-        main: "spawnUriMain",
-        newArgs: [
-          other.mainFile,
-          other.config ?? "-",
-          other.root ?? "-",
-          "$search"
-        ],
-        expect: other.expect);
+      description: "${conf.description} -spawnUri-> ${other.description}",
+      main: "spawnUriMain",
+      newArgs: [other.mainFile,
+                other.config ?? "-", other.root ?? "-", "$search"],
+      expect: other.expect
+    );
   };
 }
 
+
 /// Convert command line parameters to file paths.
 ///
 /// This only works on the command line, not with `spawnUri`.
 Configuration asPath(Configuration conf) {
   bool change = false;
 
   String toPath(String string) {
     if (string == null) return null;
     if (string.startsWith("file:")) {
       change = true;
       return new File.fromUri(Uri.parse(string)).path;
     }
     return string;
   }
 
   var mainFile = toPath(conf.mainFile);
   var root = toPath(conf.root);
   var config = toPath(conf.config);
   if (!change) return null;
-  return conf.update(
-      description: conf.description + "/as path",
-      mainFile: mainFile,
-      root: root,
-      config: config);
+  return conf.update(description: conf.description + "/as path",
+                     mainFile: mainFile, root: root, config: config);
 }
 
 /// --------------------------------------------------------------
 
+
 Future setUp() async {
   fileRoot = createTempDir();
   // print("FILES: $fileRoot");
   httpServer = await startServer(httpFiles);
   // print("HTTPS: ${httpServer.address.address}:${httpServer.port}");
   createConfigurations();
 }
 
 Future tearDown() async {
   fileRoot.deleteSync(recursive: true);
   await httpServer.close();
 }
 
 typedef Configuration ConfigurationTransformer(Configuration conf);
 
 Future runTests([List<ConfigurationTransformer> transformations]) async {
-  outer:
-  for (var config in configurations) {
+  outer: for (var config in configurations) {
     if (transformations != null) {
       for (int i = transformations.length - 1; i >= 0; i--) {
         config = transformations[i](config);
         if (config == null) {
-          continue outer; // Can be used to skip some tests.
+          continue outer;  // Can be used to skip some tests.
         }
       }
     }
     await testConfiguration(config);
   }
 }
 
 // Creates a combination of configurations for running the Dart VM.
 //
 // 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.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 `main.dart` file.
 void createConfigurations() {
-  add(String description, String mainDir,
-      {String root, String config, Map file, Map http, Map expect}) {
+  add(String description, String mainDir, {String root, String config,
+      Map file, Map http, Map expect}) {
     var id = freshName("conf");
 
     file ??= {};
     http ??= {};
 
     // Fix-up paths.
     String fileUri = fileRoot.uri.resolve("$id/").toString();
     String httpUri =
         "http://${httpServer.address.address}:${httpServer.port}/$id/";
 
@@ skipping 18 matching lines @@
     }
 
     if (!mainDir.endsWith("/")) mainDir += "/";
     // Insert main files into the main-dir map.
     Map mainDirMap;
     {
       if (mainDir.startsWith("%file/")) {
         mainDirMap = file;
       } else {
         mainDirMap = http;
+
       }
       var parts = mainDir.split('/');
       for (int i = 1; i < parts.length - 1; i++) {
         var dirName = parts[i];
         mainDirMap = mainDirMap[dirName] ?? (mainDirMap[dirName] = {});
       }
     }
 
     mainDirMap["main"] = testMain;
     mainDirMap["spawnMain"] = spawnMain.replaceAll("%mainDir/", mainDir);
     mainDirMap["spawnUriMain"] = spawnUriMain;
 
     mainDir = fixPath(mainDir);
     root = fixPath(root);
     config = fixPath(config);
     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",
-      "bar/bar": null,
+      "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"
+      "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);
     }
 
     configurations.add(new Configuration(
         description: description,
         root: root,
         config: config,
         mainFile: mainDir + "main.dart",
         args: const [],
         expect: expect));
   }
 
   // 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).
 
   // Tests that only use one scheme to access files.
   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.
     addScheme(description, main, {expect, files, args, root, config}) {
-      add("$scheme/$description", main,
-          expect: expect,
-          root: root,
-          config: config,
-          file: (scheme == "file") ? files : null,
-          http: (scheme == "http") ? files : null);
+      add("$scheme/$description", main, expect: expect,
+        root: root, config: config,
+        file: (scheme == "file") ? files : null,
+        http: (scheme == "http") ? files : null);
     }
 
     {
       // No parameters, no .packages files or packages/ dir.
       // A "file:" source realizes there is no configuration and can't resolve
       // any packages, but a "http:" source assumes a "packages/" directory.
-      addScheme("no resolution", "%$scheme/",
-          files: {},
-          expect: (scheme == "file")
-              ? {"foo.x": null}
-              : {
-                  "iroot": "%http/packages/",
-                  "foo": "%http/packages/foo",
-                  "foo/": "%http/packages/foo/",
-                  "foo/bar": "%http/packages/foo/bar",
-                  "foo.x": null,
-                  "bar/bar": "%http/packages/bar/bar",
-                });
+      addScheme("no resolution",
+        "%$scheme/",
+        files: {},
+        expect: (scheme == "file") ? {
+          "foo.x": null
+        } : {
+          "iroot": "%http/packages/",
+          "foo": "%http/packages/foo",
+          "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/": "%$scheme/packages/foo/",
-        "foo/bar": "%$scheme/packages/foo/bar",
-        "bar/bar": "%$scheme/packages/bar/bar",
-      });
+      addScheme("implicit packages dir","%$scheme/",
+        files: files,
+        expect: {
+          "iroot": "%$scheme/packages/",
+          "foo": "%$scheme/packages/foo",
+          "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/": "%$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",
-          });
+      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/": "%$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/", files: files, expect: {
-        "iconf": "%$scheme/.packages",
-        "foo/": "%$scheme/pkgs/foo/",
-        "foo/bar": "%$scheme/pkgs/foo/bar",
-      });
+      var files = {".packages": "foo:pkgs/foo/",
+                   "packages": {},
+                   "pkgs": fooPackage};
+      addScheme("implicit .packages file", "%$scheme/",
+        files: files,
+        expect: {
+          "iconf": "%$scheme/.packages",
+          "foo/": "%$scheme/pkgs/foo/",
+          "foo/bar": "%$scheme/pkgs/foo/bar",
+        });
     }
 
     {
       // No parameters, a .packages file in parent dir, no packages/ dir.
       // With a file: URI, find the .packages file.
       // WIth a http: URI, assume a packages/ dir.
-      var files = {"sub": {}, ".packages": "foo:pkgs/foo/", "pkgs": fooPackage};
+      var files = {"sub": {},
+                   ".packages": "foo:pkgs/foo/",
+                   "pkgs": fooPackage};
       addScheme(".packages file in parent", "%$scheme/sub/",
-          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/": "%http/sub/packages/foo/",
-                  "foo/bar": "%http/sub/packages/foo/bar",
-                  "foo.x": null,
-                  "bar/bar": "%http/sub/packages/bar/bar",
-                });
+        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/": "%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/": "%$scheme/notthere/foo/",
-            "foo/bar": "%$scheme/notthere/foo/bar",
-            "foo.x": null,
-            "bar/bar": "%$scheme/notthere/bar/bar",
-          });
+      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/": "%$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},
-          config: "%$scheme/.notthere",
-          expect: {
-            "pconf": "%$scheme/.notthere",
-            "iconf": null, //   <- Only there if actually loaded (unspecified).
-            "foo/": null,
-            "foo/bar": null,
-            "foo.x": null,
-          });
+      addScheme("explicit config not there",
+        "%$scheme/",
+        files: {".packages": "foo:packages/foo/",
+                "packages": fooPackage},
+        config: "%$scheme/.notthere",
+        expect: {
+          "pconf": "%$scheme/.notthere",
+          "iconf": null, //   <- Only there if actually loaded (unspecified).
+          "foo/": null,
+          "foo/bar": null,
+          "foo.x": null,
+        });
     }
 
     {
       // Specified package root with no trailing slash.
       // The Platform.packageRoot and Isolate.packageRoot has a trailing slash.
-      var files = {
-        ".packages": "foo:packages/foo/",
-        "packages": {},
-        "pkgs": fooPackage
-      };
+      var files = {".packages": "foo:packages/foo/",
+                   "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/": "%$scheme/pkgs/foo/",
-            "foo/bar": "%$scheme/pkgs/foo/bar",
-            "bar/bar": "%$scheme/pkgs/bar/bar",
-          });
+        files: files,
+        root: "%$scheme/pkgs",
+        expect: {
+          "proot": "%$scheme/pkgs/",
+          "iroot": "%$scheme/pkgs/",
+          "foo": "%$scheme/pkgs/foo",
+          "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
-      };
+      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/": "%$scheme/pkgs/foo/",
-            "foo/bar": "%$scheme/pkgs/foo/bar",
-            "bar/bar": "%$scheme/pkgs/bar/bar",
-          });
+        files: files,
+        root: "%$scheme/pkgs",
+        expect: {
+          "proot": "%$scheme/pkgs/",
+          "iroot": "%$scheme/pkgs/",
+          "foo": "%$scheme/pkgs/foo",
+          "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
-      };
+      var files = {".packages": "foo:packages/foo/",
+                   "packages": {},
+                   ".pkgs": "foo:pkgs/foo/",
+                   "pkgs": fooPackage};
       addScheme("explicit package config file", "%$scheme/",
-          files: files,
-          config: "%$scheme/.pkgs",
-          expect: {
-            "pconf": "%$scheme/.pkgs",
-            "iconf": "%$scheme/.pkgs",
-            "foo/": "%$scheme/pkgs/foo/",
-            "foo/bar": "%$scheme/pkgs/foo/bar",
-          });
+        files: files,
+        config: "%$scheme/.pkgs",
+        expect: {
+          "pconf": "%$scheme/.pkgs",
+          "iconf": "%$scheme/.pkgs",
+          "foo/": "%$scheme/pkgs/foo/",
+          "foo/bar": "%$scheme/pkgs/foo/bar",
+        });
     }
 
     {
       // Specified package config as data: URI.
       // 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 = {
-        ".packages": "foo:packages/foo/",
-        "packages": {},
-        "pkgs": fooPackage
-      };
+      var files = {".packages": "foo:packages/foo/",
+                   "packages": {},
+                   "pkgs": fooPackage};
       var dataUri = "data:,foo:%$scheme/pkgs/foo/\n";
       addScheme("explicit data: config file", "%$scheme/",
-          files: files,
-          config: dataUri,
-          expect: {
-            "pconf": dataUri,
-            "iconf": dataUri,
-            "foo/": "%$scheme/pkgs/foo/",
-            "foo/bar": "%$scheme/pkgs/foo/bar",
-          });
+        files: files,
+        config: dataUri,
+        expect: {
+          "pconf": dataUri,
+          "iconf": dataUri,
+          "foo/": "%$scheme/pkgs/foo/",
+          "foo/bar": "%$scheme/pkgs/foo/bar",
+        });
     }
   }
 
   // Tests where there are files on both http: and file: sources.
 
   for (var entryScheme in const ["file", "http"]) {
     for (var pkgScheme in const ["file", "http"]) {
       // Package root.
       if (entryScheme != pkgScheme) {
         // Package dir and entry point on different schemes.
         var files = {};
         var https = {};
         (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/": "%$pkgScheme/pkgs/foo/",
-              "foo/bar": "%$pkgScheme/pkgs/foo/bar",
-              "bar/bar": "%$pkgScheme/pkgs/bar/bar",
-              "foo.x": "qux",
-            });
+          file: files, http: https,
+          root: "%$pkgScheme/pkgs/",
+          expect: {
+            "proot": "%$pkgScheme/pkgs/",
+            "iroot": "%$pkgScheme/pkgs/",
+            "foo": "%$pkgScheme/pkgs/foo",
+            "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 = {};
         (entryScheme == "file" ? files : https)["main"] = testMain;
         (configScheme == "file" ? files : https)[".pkgs"] =
             "foo:%$pkgScheme/pkgs/foo/\n";
         (pkgScheme == "file" ? files : https)["pkgs"] = fooPackage;
         add("$pkgScheme pkg/$configScheme config/$entryScheme main",
-            "%$entryScheme/",
-            file: files,
-            http: https,
-            config: "%$configScheme/.pkgs",
-            expect: {
-              "pconf": "%$configScheme/.pkgs",
-              "iconf": "%$configScheme/.pkgs",
-              "foo/": "%$pkgScheme/pkgs/foo/",
-              "foo/bar": "%$pkgScheme/pkgs/foo/bar",
-              "foo.x": "qux",
-            });
+          "%$entryScheme/",
+          file: files, http: https,
+          config: "%$configScheme/.pkgs",
+          expect: {
+            "pconf": "%$configScheme/.pkgs",
+            "iconf": "%$configScheme/.pkgs",
+            "foo/": "%$pkgScheme/pkgs/foo/",
+            "foo/bar": "%$pkgScheme/pkgs/foo/bar",
+            "foo.x": "qux",
+          });
       }
     }
   }
 }
 
+
 // ---------------------------------------------------------
 // Helper functionality.
 
 var fileHttpRegexp = new RegExp(r"%(?:file|http)/");
 
 // Executes a test in a configuration.
 //
 // The test must specify which main file to use
 // (`main`, `spawnMain` or `spawnUriMain`)
 // and any arguments which will be used by `spawnMain` and `spawnUriMain`.
 //
 // The [expect] map may be used to override the expectations of the
 // configuration on a value-by-value basis. Passing, e.g., `{"pconf": null}`
 // will override only the `pconf` (`Platform.packageConfig`) expectation.
 Future testConfiguration(Configuration conf) async {
   print("-- ${conf.description}");
   var description = conf.description;
   try {
     var output = await execDart(conf.mainFile,
-        root: conf.root, config: conf.config, scriptArgs: conf.args);
+                                root: conf.root,
+                                config: conf.config,
+                                scriptArgs: conf.args);
     match(JSON.decode(output), conf.expect, description, output);
   } catch (e, s) {
     // Unexpected error calling execDart or parsing the result.
     // Report it and continue.
     print("ERROR running $description: $e\n$s");
     failingTests.putIfAbsent(description, () => []).add("$e");
   }
 }
 
+
 /// 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 desc, String actualJson) {
   for (var key in expectations.keys) {
     var expectation = expectations[key]?.toString();
     var actual = actuals[key];
     if (expectation != actual) {
       print("ERROR: $desc: $key: Expected: <$expectation> Found: <$actual>");
-      failingTests
-          .putIfAbsent(desc, () => [])
-          .add("$key: $expectation != $actual");
+      failingTests.putIfAbsent(desc, ()=>[]).add(
+          "$key: $expectation != $actual");
     }
   }
 }
 
-const String improt = "import"; // Avoid multitest import rewriting.
+const String improt = "import";  // Avoid multitest import rewriting.
 
 /// Script that prints the current state and the result of resolving
 /// a few package URIs. This script will be invoked in different settings,
 /// and the result will be parsed and compared to the expectations.
 const String testMain = """
 $improt "dart:convert" show JSON;
 $improt "dart:io" show Platform, Directory;
 $improt "dart:isolate" show Isolate;
 $improt "package:foo/foo.dart" deferred as foo;
 main(_) async {
@@ skipping 89 matching lines @@
   } else if (arg == "spawnUriMain") {
     target = spawnUri.main;
   } else {
     target = main;
   }
   Isolate.spawn(target, rest, onError: port.sendPort, onExit: port.sendPort);
 }
 """;
 
 /// A package directory containing only one package, "foo", with one file.
-const Map fooPackage = const {
-  "foo": const {"foo": "var x = 'qux';"}
-};
+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> execDart(String script,
-    {String root, String config, Iterable<String> scriptArgs}) async {
+                        {String root, String config,
+                         Iterable<String> scriptArgs}) async {
   var checked = false;
   assert((checked = true));
   // TODO: Find a way to change CWD before running script.
   var executable = Platform.executable;
   var args = [];
   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) {
@@ skipping 23 matching lines @@
     File newFile = new File(p.join(base.path, name));
     newFile.writeAsStringSync(content);
   }
 
   void createRecursive(Directory dir, Map map) {
     for (var name in map.keys) {
       var content = map[name];
       if (content is String) {
         // If the name starts with "." it's a .packages file, otherwise it's
         // a dart file. Those are the only files we care about in this test.
-        createTextFile(
-            dir, name.startsWith(".") ? name : name + ".dart", content);
+        createTextFile(dir,
+                       name.startsWith(".") ? name : name + ".dart",
+                       content);
       } else {
         assert(content is Map);
         var subdir = createDir(dir, name);
         createRecursive(subdir, content);
       }
     }
   }
 
   createRecursive(createDir(tempDir, subDir), content);
 }
 
 /// Start an HTTP server which serves a directory/file structure.
 ///
 /// The directories and files are described by [files].
 ///
 /// Each map key is an entry in a directory. A `Map` value is a sub-directory
 /// and a `String` value is a text file.
 /// The file contents are run through [fixPaths] to allow them to be self-
 /// referential.
 Future<HttpServer> startServer(Map files) async {
   return (await HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 0))
-    ..forEach((request) {
-      var result = files;
-      onFailure:
-      {
-        for (var part in request.uri.pathSegments) {
-          if (part.endsWith(".dart")) {
-            part = part.substring(0, part.length - 5);
+      ..forEach((request) {
+        var result = files;
+        onFailure: {
+          for (var part in request.uri.pathSegments) {
+            if (part.endsWith(".dart")) {
+              part = part.substring(0, part.length - 5);
+            }
+            if (result is Map) {
+              result = result[part];
+            } else {
+              break onFailure;
+            }
           }
-          if (result is Map) {
-            result = result[part];
-          } else {
-            break onFailure;
+          if (result is String) {
+            request.response..write(result)
+                            ..close();
+            return;
           }
         }
-        if (result is String) {
-          request.response
-            ..write(result)
-            ..close();
-          return;
-        }
-      }
-      request.response
-        ..statusCode = HttpStatus.NOT_FOUND
-        ..close();
-    });
+        request.response..statusCode = HttpStatus.NOT_FOUND
+                        ..close();
+      });
 }
 
 // Counter used to avoid reusing temporary file or directory names.
 //
 // Used when adding extra files to an existing directory structure,
 // and when creating temporary directories.
 //
 // Some platform temporary-directory implementations are timer based,
 // and creating two temp-dirs withing a short duration may cause a collision.
 int tmpNameCounter = 0;
 
 // Fresh file name.
 String freshName([String base = "tmp"]) => "$base${tmpNameCounter++}";
 
 Directory createTempDir() {
   return Directory.systemTemp.createTempSync(freshName("pftest-"));
 }
 
 typedef void ConfigUpdate(Configuration configuration);
 
 /// The configuration for a single test.
 class Configuration {
   /// The "description" of the test - a description of the set-up.
   final String description;
-
   /// The package root parameter passed to the Dart isolate.
   ///
   /// At most one of [root] and [config] should be supplied. If both are
   /// omitted, a VM will search for a packages file or dir.
   final String root;
-
   /// The package configuration file location passed to the Dart isolate.
   final String config;
-
   /// Path to the main file to run.
   final String mainFile;
-
   /// List of arguments to pass to the main function.
   final List<String> args;
-
   /// The expected values for `Platform.package{Root,Config}`,
   /// `Isolate.package{Root,Config}` and resolution of package URIs
   /// in a `foo` package.
   ///
   /// The results are found by running the `main.dart` file inside [mainDir].
   /// The tests can run this file after doing other `spawn` or `spawnUri` calls.
   final Map expect;
 
-  Configuration(
-      {this.description,
-      this.root,
-      this.config,
-      this.mainFile,
-      this.args,
-      this.expect});
+  Configuration({this.description,
+                 this.root,
+                 this.config,
+                 this.mainFile,
+                 this.args,
+                 this.expect});
 
   // Gets the type of main file, one of `main`, `spawnMain` or `spawnUriMain`.
   String get mainType {
     var lastSlash = mainFile.lastIndexOf("/");
     if (lastSlash < 0) {
       // Assume it's a Windows path.
       lastSlash = mainFile.lastIndexOf(r"\");
     }
     var name = mainFile.substring(lastSlash + 1, mainFile.length - 5);
     assert(name == "main" || name == "spawnMain" || name == "spawnUriMain");
@@ skipping 19 matching lines @@
   /// [mainFile] overrides [Configuration.mainFile] completely, and ignores
   /// [main].
   ///
   /// [newArgs] are prepended to the existing [Configuration.args].
   ///
   /// [args] overrides [Configuration.args] completely and ignores [newArgs].
   ///
   /// [expect] overrides individual expectations.
   ///
   /// [root] and [config] overrides the existing values.
-  Configuration update(
-      {String description,
+  Configuration update({
+      String description,
       String main,
       String mainFile,
       String root,
       String config,
       List<String> args,
       List<String> newArgs,
-      Map expect}) {
+      Map expect
+    }) {
     return new Configuration(
-        description: description ?? this.description,
-        root: root ?? this.root,
-        config: config ?? this.config,
-        mainFile: mainFile ??
-            ((main == null) ? this.mainFile : "${this.mainPath}$main.dart"),
-        args: args ??
-            (<String>[]
-              ..addAll(newArgs ?? const <String>[])
-              ..addAll(this.args)),
-        expect: expect == null ? this.expect : new Map.from(this.expect)
-          ..addAll(expect ?? const {}));
+      description: description ?? this.description,
+      root: root ?? this.root,
+      config: config ?? this.config,
+      mainFile: mainFile ??
+          ((main == null) ? this.mainFile : "${this.mainPath}$main.dart"),
+      args:
+          args ?? (<String>[]..addAll(newArgs ?? const <String>[])
+                             ..addAll(this.args)),
+      expect: expect == null
+          ? this.expect
+          : new Map.from(this.expect)..addAll(expect ?? const {}));
   }
 
   // For debugging.
   String toString() {
     return "Configuration($description\n"
-        "  root  : $root\n"
-        "  config: $config\n"
-        "  main  : $mainFile\n"
-        "  args  : ${args.map((x) => '"$x"').join(" ")}\n"
-        ") : expect {\n${expect.keys.map((k) =>
+      "  root  : $root\n"
+      "  config: $config\n"
+      "  main  : $mainFile\n"
+      "  args  : ${args.map((x) => '"$x"').join(" ")}\n"
+      ") : expect {\n${expect.keys.map((k) =>
            '  "$k"'.padRight(6) + ":${JSON.encode(expect[k])}\n").join()}"
-        "}";
+      "}";
   }
 }
 
+
 // Inserts the file with generalized [name] at [path] with [content].
 //
 // The [path] is a directory where the file is created. It must start with
 // either '%file/' or '%http/' to select the structure to put it into.
 //
 // The [name] should not have a trailing ".dart" for Dart files. Any file
 // not starting with "." is assumed to be a ".dart" file.
-void insertFileAt(
-    Map file, Map http, String path, String name, String content) {
+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;
 }