1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24  /*
  25  * @test
  26  * @bug 8168423
  27  * @summary Different types of ClassLoader running with(out) SecurityManager and
  28  *          (in)valid security policy file.
  29  * @library /lib/testlibrary
  30  * @modules java.base/jdk.internal.module
  31  * @build JarUtils CompilerUtils
  32  * @run main/timeout=240 ClassLoaderTest






  33  */
  34 import java.io.File;
  35 import java.io.OutputStream;
  36 import java.nio.file.Files;
  37 import java.nio.file.Path;
  38 import java.nio.file.Paths;
  39 import java.nio.file.StandardCopyOption;
  40 import java.util.Map;
  41 import java.util.HashMap;
  42 import java.lang.module.ModuleDescriptor;



  43 import jdk.internal.module.ModuleInfoWriter;
  44 import jdk.testlibrary.ProcessTools;
  45 
  46 public class ClassLoaderTest {
  47 
  48     private static final String SRC = System.getProperty("test.src");
  49     private static final Path CL_SRC = Paths.get(SRC, "TestClassLoader.java");
  50     private static final Path C_SRC = Paths.get(SRC, "TestClient.java");
  51     private static final Path CL_BIN = Paths.get("classes", "clbin");
  52     private static final Path C_BIN = Paths.get("classes", "cbin");
  53     private static final Path ARTIFACT_DIR = Paths.get("jars");
  54     private static final Path VALID_POLICY = Paths.get(SRC, "valid.policy");
  55     private static final Path INVALID_POLICY
  56             = Paths.get(SRC, "malformed.policy");
  57     private static final Path NO_POLICY = null;
  58     private static final String LOCALE = "-Duser.language=en -Duser.region=US";
  59     /*
  60      * Here is the naming convention followed for each jar.
  61      * cl.jar   - Regular custom class loader jar.
  62      * mcl.jar  - Modular custom class loader jar.
  63      * c.jar    - Regular client jar.
  64      * mc.jar   - Modular client jar.
  65      * amc.jar  - Modular client referring automated custom class loader jar.
  66      */
  67     private static final Path CL_JAR = ARTIFACT_DIR.resolve("cl.jar");
  68     private static final Path MCL_JAR = ARTIFACT_DIR.resolve("mcl.jar");
  69     private static final Path C_JAR = ARTIFACT_DIR.resolve("c.jar");
  70     private static final Path MC_JAR = ARTIFACT_DIR.resolve("mc.jar");
  71     private static final Path AMC_JAR = ARTIFACT_DIR.resolve("amc.jar");
  72     private static final Map<String, String> MSG_MAP = new HashMap<>();
  73 
  74     static {
  75         // This mapping help process finding expected message based
  76         // on the key passed as argument while executing java command.
  77         MSG_MAP.put("MissingModule", "Module cl not found, required by mc");
  78         MSG_MAP.put("ErrorPolicy", "java.security.policy: error parsing file");
  79         MSG_MAP.put(
  80                 "SystemCL", "jdk.internal.loader.ClassLoaders$AppClassLoader");
  81         MSG_MAP.put("CustomCL", "cl.TestClassLoader");



















































  82     }
  83 
  84     public static void main(String[] args) throws Exception {



















  85 
  86         // Generates regular and modular jars before start processing it.
  87         setUp();
  88         processForEachPolicyFile();
  89     }
  90 
  91     /**
  92      * Test cases are based on the following logic,
  93      *  for (policyFile : {"NO_POLICY", "VALID", "MALFORMED"}) {
  94      *      for (classLoader : {"SystemClassLoader", "CustomClassLoader"}){
  95      *          for (clientModule : {"NAMED", "AUTOMATIC", "UNNAMED"}) {
  96      *              for (classLoaderModule : {"NAMED", "AUTOMATIC", "UNNAMED"}) {
  97      *                  Create and run java command for each possible Test case
  98      *              }
  99      *          }
 100      *      }
 101      *  }
 102      */
 103     private static void processForEachPolicyFile() throws Exception {
 104 
 105         final String regCLloc = CL_JAR.toFile().getAbsolutePath();
 106         final String modCLloc = MCL_JAR.toFile().getAbsolutePath();
 107         final String regCloc = C_JAR.toFile().getAbsolutePath();
 108         final String modCloc = MC_JAR.toFile().getAbsolutePath();
 109         final String autoModCloc = AMC_JAR.toFile().getAbsolutePath();
 110         final String separator = File.pathSeparator;
 111 
 112         for (Path policy
 113                 : new Path[]{NO_POLICY, VALID_POLICY, INVALID_POLICY}) {
 114             final String policyFile = (policy != null)
 115                     ? policy.toFile().getAbsolutePath() : null;
 116             final boolean malformedPolicy
 117                     = (policy == null) ? false : policy.equals(INVALID_POLICY);
 118 
 119             for (boolean useSCL : new boolean[]{true, false}) {
 120                 final String clVmArg = (useSCL) ? ""
 121                         : "-Djava.system.class.loader=cl.TestClassLoader";
 122                 final String autoAddModArg
 123                         = (useSCL) ? "" : "--add-modules=cl";
 124                 final String addmodArg = (useSCL) ? "" : "--add-modules=mcl";
 125                 final String sMArg = (policy != null) ? String.format(
 126                         "-Djava.security.manager -Djava.security.policy=%s",
 127                         policyFile) : "";
 128                 final String smMsg = (policy != null) ? "With SecurityManager"
 129                         : "Without SecurityManager";
 130                 final String expectedResult = ((!malformedPolicy)
 131                         ? ((useSCL) ? "PASS SystemCL" : "PASS CustomCL")
 132                         : "FAIL ErrorPolicy");
 133 
 134                 // NAMED-NAMED, NAMED-AUTOMATIC, NAMED-UNNAMED
 135                 System.out.printf("Case:- Modular Client and %s %s%n",
 136                         ((useSCL) ? "SystemClassLoader"
 137                                 : "Modular CustomClassLoader"), smMsg);
 138                 execute(new String[]{String.format(
 139                     "--module-path %s%s%s %s %s %s -m mc/c.TestClient",
 140                     modCloc, separator, modCLloc, LOCALE, clVmArg, sMArg),
 141                     expectedResult});
 142                 System.out.printf("Case:- Modular Client and %s %s%n", ((useSCL)
 143                         ? "SystemClassLoader"
 144                         : "Automatic modular CustomClassLoader"), smMsg);
 145                 execute(new String[]{String.format(
 146                     "--module-path %s%s%s %s %s %s -m mc/c.TestClient",
 147                     autoModCloc, separator, regCLloc, LOCALE, clVmArg, sMArg),
 148                     expectedResult});
 149                 System.out.printf("Case:- Modular Client and %s %s%n", ((useSCL)
 150                         ? "SystemClassLoader"
 151                         : "Unknown modular CustomClassLoader"), smMsg);
 152                 execute(new String[]{String.format(
 153                     "--module-path %s -cp %s %s %s %s -m mc/c.TestClient",
 154                     autoModCloc, regCLloc, LOCALE, clVmArg, sMArg),
 155                     "FAIL MissingModule"});
 156 
 157                 // AUTOMATIC-NAMED, AUTOMATIC-AUTOMATIC, AUTOMATIC-UNNAMED
 158                 System.out.printf("Case:- Automated modular Client and %s %s%n",
 159                         ((useSCL) ? "SystemClassLoader"
 160                                 : "Modular CustomClassLoader"), smMsg);
 161                 execute(new String[]{String.format(
 162                     "--module-path %s%s%s %s %s %s %s -m c/c.TestClient",
 163                     regCloc, separator, modCLloc, addmodArg, LOCALE, clVmArg,
 164                     sMArg), expectedResult});
 165                 System.out.printf("Case:- Automated modular Client and %s %s%n",
 166                         ((useSCL) ? "SystemClassLoader"
 167                                 : "Automatic modular CustomClassLoader"),
 168                         smMsg);
 169                 execute(new String[]{String.format(
 170                     "--module-path %s%s%s %s %s %s %s -m c/c.TestClient",
 171                     regCloc, separator, regCLloc, autoAddModArg, LOCALE,
 172                     clVmArg, sMArg), expectedResult});
 173                 System.out.printf("Case:- Automated modular Client and %s %s%n",
 174                         ((useSCL) ? "SystemClassLoader"
 175                                 : "Unknown modular CustomClassLoader"), smMsg);
 176                 execute(new String[]{String.format(
 177                     "--module-path %s -cp %s %s %s %s -m c/c.TestClient",
 178                     regCloc, regCLloc, LOCALE, clVmArg, sMArg),
 179                     expectedResult});
 180 
 181                 // UNNAMED-NAMED, UNNAMED-AUTOMATIC, UNNAMED-UNNAMED
 182                 System.out.printf("Case:- Unknown modular Client and %s %s%n",
 183                         ((useSCL) ? "SystemClassLoader"
 184                                 : "Modular CustomClassLoader"), smMsg);
 185                 execute(new String[]{String.format(
 186                     "-cp %s --module-path %s %s %s %s %s c.TestClient",
 187                     regCloc, modCLloc, addmodArg, LOCALE, clVmArg, sMArg),
 188                     expectedResult});
 189                 System.out.printf("Case:- Unknown modular Client and %s %s%n",
 190                         ((useSCL) ? "SystemClassLoader"
 191                                 : "Automatic modular CustomClassLoader"),
 192                         smMsg);
 193                 execute(new String[]{String.format(
 194                     "-cp %s --module-path %s %s %s %s %s c.TestClient",
 195                     regCloc, regCLloc, autoAddModArg, LOCALE, clVmArg, sMArg),
 196                     expectedResult});
 197                 System.out.printf("Case:- Unknown modular Client and %s %s%n",
 198                         ((useSCL) ? "SystemClassLoader"
 199                                 : "Unknown modular CustomClassLoader"), smMsg);
 200                 execute(new String[]{String.format(
 201                     "-cp %s%s%s %s %s %s c.TestClient", regCloc, separator,
 202                     regCLloc, LOCALE, clVmArg, sMArg), expectedResult});
 203 
 204                 // Regular jars in module-path and Modular jars in class-path.
 205                 System.out.printf("Case:- Regular Client and %s "
 206                         + "inside --module-path %s.%n", ((useSCL)
 207                                 ? "SystemClassLoader"
 208                                 : "Unknown modular CustomClassLoader"), smMsg);
 209                 execute(new String[]{String.format(
 210                     "--module-path %s%s%s %s %s %s %s -m c/c.TestClient",
 211                     regCloc, separator, regCLloc, autoAddModArg, LOCALE,
 212                     clVmArg, sMArg), expectedResult});
 213                 System.out.printf("Case:- Modular Client and %s in -cp %s%n",

 214                         ((useSCL) ? "SystemClassLoader"
 215                                 : "Modular CustomClassLoader"), smMsg);
 216                 execute(new String[]{String.format(
 217                     "-cp %s%s%s %s %s %s c.TestClient", modCloc, separator,
 218                     modCLloc, LOCALE, clVmArg, sMArg), expectedResult});
 219             }
 220         }



 221     }
 222 
 223     /**
 224      * Execute with command arguments and process the result.
 225      */
 226     private static void execute(String[] args) throws Exception {
 227 
 228         String status = null;
 229         String msgKey = null;
 230         if ((args != null && args.length > 1)) {
 231             String[] secArgs = args[1].split("\\s+");
 232             status = (secArgs.length > 0) ? secArgs[0] : null;
 233             msgKey = (secArgs.length > 1) ? secArgs[1] : null;
 234         }
 235         String out = ProcessTools.executeTestJvm(args[0].split("\\s+"))
 236                 .getOutput();
 237         // Handle response.
 238         if ((status != null && "PASS".equals(status) && msgKey != null
 239                 && out.contains(MSG_MAP.get(msgKey)))) {
 240             System.out.printf("PASS: Expected Result: %s.%n",
 241                     MSG_MAP.get(msgKey));
 242         } else if ((status != null && "FAIL".equals(status) && msgKey != null
 243                 && out.contains(MSG_MAP.get(msgKey)))) {
 244             System.out.printf("PASS: Expected Failure: %s.%n",
 245                     MSG_MAP.get(msgKey));
 246         } else if (out.contains("Exception") || out.contains("Error")) {
 247             System.out.printf("OUTPUT: %s", out);
 248             throw new RuntimeException("FAIL: Unknown Exception.");
 249         } else {
 250             System.out.printf("OUTPUT: %s", out);
 251             throw new RuntimeException("FAIL: Unknown Test case found");
 252         }
 253     }
 254 
 255     /**
 256      * Creates regular/modular jar files for TestClient and TestClassLoader.
 257      */
 258     private static void setUp() throws Exception {
 259 
 260         boolean compiled = CompilerUtils.compile(CL_SRC, CL_BIN);
 261         compiled &= CompilerUtils.compile(C_SRC, C_BIN);
 262         if (!compiled) {
 263             throw new RuntimeException("Test Setup failed.");
 264         }
 265         // Generate regular jar files for TestClient and TestClassLoader
 266         JarUtils.createJarFile(CL_JAR, CL_BIN);
 267         JarUtils.createJarFile(C_JAR, C_BIN);


 268         // Generate modular jar files for TestClient and TestClassLoader with
 269         // their corresponding ModuleDescriptor.
 270         Files.copy(CL_JAR, MCL_JAR, StandardCopyOption.REPLACE_EXISTING);

 271         updateModuleDescr(MCL_JAR, ModuleDescriptor.newModule("mcl")
 272                 .exports("cl").requires("java.base").build());
 273         Files.copy(C_JAR, MC_JAR, StandardCopyOption.REPLACE_EXISTING);

 274         updateModuleDescr(MC_JAR, ModuleDescriptor.newModule("mc")
 275                 .exports("c").requires("java.base").requires("mcl").build());
 276         Files.copy(C_JAR, AMC_JAR, StandardCopyOption.REPLACE_EXISTING);

 277         updateModuleDescr(AMC_JAR, ModuleDescriptor.newModule("mc")
 278                 .exports("c").requires("java.base").requires("cl").build());
 279     }
 280 
 281     /**
 282      * Update regular jars and include module-info.class inside it to make
 283      * modular jars.
 284      */
 285     private static void updateModuleDescr(Path jar, ModuleDescriptor mDescr)
 286             throws Exception {
 287         if (mDescr != null) {
 288             Path dir = Files.createTempDirectory("tmp");
 289             Path mi = dir.resolve("module-info.class");
 290             try (OutputStream out = Files.newOutputStream(mi)) {
 291                 ModuleInfoWriter.write(mDescr, out);
 292             }
 293             System.out.format("Adding 'module-info.class' to jar '%s'%n", jar);
 294             JarUtils.updateJarFile(jar, dir);
 295         }
 296     }
 297 }
--- EOF ---