gt:         List<String> commands = new ArrayList<>();
context: /*
   * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  import java.io.*;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.util.*;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  import java.util.function.Consumer;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  import javax.tools.JavaCompiler;
  import javax.tools.JavaFileObject;
  import javax.tools.StandardJavaFileManager;
  import javax.tools.StandardLocation;
  import javax.tools.ToolProvider;
  import jdk.testlibrary.FileUtils;
  import jdk.testlibrary.JDKToolFinder;
  import static java.lang.String.format;
  import static java.util.Arrays.asList;
  
  /*
   * @test
   * @bug 8064924
   * @summary Basic test for URLStreamHandlerProvider
   * @library /lib/testlibrary
   * @build jdk.testlibrary.FileUtils jdk.testlibrary.JDKToolFinder
   * @compile Basic.java Child.java
   * @run main Basic
   */
  
  public class Basic {
  
      static final Path TEST_SRC = Paths.get(System.getProperty("test.src", "."));
      static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));
  
      public static void main(String[] args) throws Throwable {
          unknownProtocol("foo", UNKNOWN);
          unknownProtocol("bar", UNKNOWN);
          viaProvider("baz", KNOWN);
          viaProvider("bert", KNOWN);
          viaProvider("ernie", UNKNOWN, "-Djava.security.manager");
          viaProvider("curly", UNKNOWN, "-Djava.security.manager");
          viaProvider("larry", KNOWN, "-Djava.security.manager",
                  "-Djava.security.policy=" + TEST_SRC + File.separator + "basic.policy");
          viaProvider("moe", KNOWN, "-Djava.security.manager",
                  "-Djava.security.policy=" + TEST_SRC + File.separator + "basic.policy");
          viaBadProvider("tom", SCE);
          viaBadProvider("jerry", SCE);
      }
  
      static final Consumer<Result> KNOWN = r -> {
          if (r.exitValue != 0 || !r.output.isEmpty())
              throw new RuntimeException(r.output);
      };
      static final Consumer<Result> UNKNOWN = r -> {
          if (r.exitValue == 0 ||
              !r.output.contains("java.net.MalformedURLException: unknown protocol")) {
              throw new RuntimeException("exitValue: "+ r.exitValue + ", output:[" +r.output +"]");
          }
      };
      static final Consumer<Result> SCE = r -> {
          if (r.exitValue == 0 ||
              !r.output.contains("java.util.ServiceConfigurationError")) {
              throw new RuntimeException("exitValue: "+ r.exitValue + ", output:[" +r.output +"]");
          }
      };
  
      static void unknownProtocol(String protocol, Consumer<Result> resultChecker) {
          System.out.println("\nTesting " + protocol);
          Result r = java(Collections.emptyList(), asList(TEST_CLASSES),
                  "Child", protocol);
          resultChecker.accept(r);
      }
  
      static void viaProvider(String protocol, Consumer<Result> resultChecker,
                              String... sysProps)
          throws Exception
      {
          viaProviderWithTemplate(protocol, resultChecker,
                                  TEST_SRC.resolve("provider.template"),
                                  sysProps);
      }
  
      static void viaBadProvider(String protocol, Consumer<Result> resultChecker,
                                 String... sysProps)
          throws Exception
      {
          viaProviderWithTemplate(protocol, resultChecker,
                                  TEST_SRC.resolve("bad.provider.template"),
                                  sysProps);
      }
  
      static void viaProviderWithTemplate(String protocol,
                                          Consumer<Result> resultChecker,
                                          Path template, String... sysProps)
          throws Exception
      {
          System.out.println("\nTesting " + protocol);
          Path testRoot = Paths.get("URLStreamHandlerProvider-" + protocol);
          if (Files.exists(testRoot))
              FileUtils.deleteFileTreeWithRetry(testRoot);
          Files.createDirectory(testRoot);
  
          Path srcPath = Files.createDirectory(testRoot.resolve("src"));
          Path srcClass = createProvider(protocol, template, srcPath);
  
          Path build = Files.createDirectory(testRoot.resolve("build"));
          javac(build, srcClass);
          createServices(build, protocol);
          Path testJar = testRoot.resolve("test.jar");
          jar(testJar, build);
  
          List<String> props = new ArrayList<>();
          for (String p : sysProps)
              props.add(p);
  
          Result r = java(props, asList(testJar, TEST_CLASSES),
                          "Child", protocol);
  
          resultChecker.accept(r);
      }
  
      static String platformPath(String p) { return p.replace("/", File.separator); }
      static String binaryName(String name) { return name.replace(".", "/"); }
  
      static final String SERVICE_IMPL_PREFIX = "net.java.openjdk.test";
  
      static void createServices(Path dst, String protocol) throws IOException {
          Path services = Files.createDirectories(dst.resolve("META-INF")
                                                     .resolve("services"));
  
          final String implName =  SERVICE_IMPL_PREFIX + "." + protocol + ".Provider";
          Path s = services.resolve("java.net.spi.URLStreamHandlerProvider");
          FileWriter fw = new FileWriter(s.toFile());
          try {
              fw.write(implName);
          } finally {
              fw.close();
          }
      }
  
      static Path createProvider(String protocol, Path srcTemplate, Path dst)
          throws IOException
      {
          String pkg = SERVICE_IMPL_PREFIX + "." + protocol;
          Path classDst = dst.resolve(platformPath(binaryName(pkg)));
          Files.createDirectories(classDst);
          Path classPath = classDst.resolve("Provider.java");
  
          List<String> lines = Files.lines(srcTemplate)
                                    .map(s -> s.replaceAll("\\$package", pkg))
                                    .map(s -> s.replaceAll("\\$protocol", protocol))
                                    .collect(Collectors.toList());
          Files.write(classPath, lines);
  
          return classPath;
      }
  
      static void jar(Path jarName, Path jarRoot) { String jar = getJDKTool("jar");
          ProcessBuilder p = new ProcessBuilder(jar, "cf", jarName.toString(),
                  "-C", jarRoot.toString(), ".");
          quickFail(run(p));
      }
  
      static void javac(Path dest, Path... sourceFiles) throws IOException {
          JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
          try (StandardJavaFileManager fileManager =
                      compiler.getStandardFileManager(null, null, null)) {
  
              List<File> files = Stream.of(sourceFiles)
                      .map(p -> p.toFile())
                      .collect(Collectors.toList());
              List<File> dests = Stream.of(dest)
                      .map(p -> p.toFile())
                      .collect(Collectors.toList());
              Iterable<? extends JavaFileObject> compilationUnits =
                      fileManager.getJavaFileObjectsFromFiles(files);
              fileManager.setLocation(StandardLocation.CLASS_OUTPUT, dests);
              JavaCompiler.CompilationTask task =
                      compiler.getTask(null, fileManager, null, null, null, compilationUnits);
              boolean passed = task.call();
              if (!passed)
                  throw new RuntimeException("Error compiling " + files);
          }
      }
  
      static void quickFail(Result r) {
          if (r.exitValue != 0)
              throw new RuntimeException(r.output);
      }
  
      static Result java(List<String> sysProps, Collection<Path> classpath,
                         String classname, String arg) {
          String java = getJDKTool("java");
  
  