26 import java.util.LinkedHashMap;

    27 import java.nio.file.StandardCopyOption;

    28 import java.util.Collections;

    29 import java.util.LinkedList;

    30 import java.io.IOException;

    32 import java.io.File;

    33 import java.io.OutputStream;

    32 import java.util.ArrayList;

    35 import java.lang.module.ModuleDescriptor.Builder;

    33 import jdk.testlibrary.ProcessTools;

    36 import jdk.internal.module.ModuleInfoWriter;

    34 import jdk.testlibrary.OutputAnalyzer;

    37 import java.util.stream.Stream;

    35 import jdk.test.lib.compiler.CompilerUtils;

    38 import jdk.test.lib.process.ProcessTools;

    36 import org.testng.annotations.BeforeTest;

    39 import jdk.test.lib.process.OutputAnalyzer;

    37 

    40 

    38 /**

    41 

    42 /*

    40  * @bug 8078813

    44  * @bug 8078813 8183310

    45  * @summary Test custom JAAS login module with all possible modular option.

    42  * @library /java/security/modules

    47  * @modules java.base/jdk.internal.module

    43  * @build jdk.test.lib.compiler.CompilerUtils JarUtils

    48  * @build JarUtils

    44  * @summary Test custom JAAS module with all possible modular option. The test

    49  * @build TestLoginModule JaasClient

    45  *          includes different combination of JAAS client/login modules

    50  * @run main JaasModularClientTest false

    46  *          interaction with or without service description.

    51  * @run main JaasModularClientTest true

    47  * @run testng JaasModularClientTest

    49 public class JaasModularClientTest extends ModularTest {

    53 public class JaasModularClientTest {

    50 

    54 

    51     private static final Path S_SRC = SRC.resolve("TestLoginModule.java");

    55     private static final Path SRC = Paths.get(System.getProperty("test.src"));

    52     private static final String S_PKG = "login";

    56     private static final Path TEST_CLASSES

    53     private static final String S_JAR_NAME = S_PKG + JAR_EXTN;

    57             = Paths.get(System.getProperty("test.classes"));

    54     private static final String S_DESCR_JAR_NAME = S_PKG + DESCRIPTOR

    58     private static final Path ARTIFACT_DIR = Paths.get("jars");

    55             + JAR_EXTN;

    59     private static final String PS = File.pathSeparator;

    56     private static final String MS_JAR_NAME = MODULAR + S_PKG + JAR_EXTN;

    60     private static final String L_TYPE = "login.TestLoginModule";

    57     private static final String MS_DESCR_JAR_NAME = MODULAR + S_PKG + DESCRIPTOR

    61     private static final String C_TYPE = "client.JaasClient";

    58             + JAR_EXTN;

    62 

    59 

    63     /**

    60     private static final Path C_SRC = SRC.resolve("JaasClient.java");

    64      * Here is the naming convention followed.

    61     private static final String C_PKG = "client";

    65      * l.jar    - Unnamed login module jar.

    62     private static final String C_JAR_NAME = C_PKG + JAR_EXTN;

    66      * ml.jar   - Modular login module jar.

    63     private static final String MCN_JAR_NAME = MODULAR + C_PKG + "N" + JAR_EXTN;

    67      * msl.jar  - Modular login module jar provides login module service

    64     private static final String MC_JAR_NAME = MODULAR + C_PKG + JAR_EXTN;

    68      *            through module-info

    65 

    69      * c.jar    - Unnamed client jar.

    66     private static final Path BUILD_DIR = Paths.get(".").resolve("build");

    70      * mc.jar   - Modular client jar.

    67     private static final Path COMPILE_DIR = BUILD_DIR.resolve("bin");

    71      * mcs.jar  - Modular client jar uses login module service through

    68     private static final Path S_BUILD_DIR = COMPILE_DIR.resolve(S_PKG);

    72      *            module-info.

    69     private static final Path S_WITH_META_DESCR_BUILD_DIR = COMPILE_DIR.resolve(

    73      * amc.jar  - Modular client used for automatic login module jar.

    70             S_PKG + DESCRIPTOR);

    74      * amcs.jar - Modular client used for automatic login module jar and uses

    71     private static final Path C_BLD_DIR = COMPILE_DIR.resolve(C_PKG);

    75      *            login module service through module-info.

    72     private static final Path M_BASE_PATH = BUILD_DIR.resolve("mbase");

    76      */

    73     private static final Path ARTIFACTS_DIR = BUILD_DIR.resolve("artifacts");

    77     private static final Path L_JAR = artifact("l.jar");

    74 

    78     private static final Path ML_JAR = artifact("ml.jar");

    75     private static final Path S_ARTIFACTS_DIR = ARTIFACTS_DIR.resolve(S_PKG);

    79     private static final Path MSL_JAR = artifact("msl.jar");

    76     private static final Path S_JAR = S_ARTIFACTS_DIR.resolve(S_JAR_NAME);

    80     private static final Path C_JAR = artifact("c.jar");

    77     private static final Path S_WITH_DESCRIPTOR_JAR = S_ARTIFACTS_DIR.resolve(

    81     private static final Path MC_JAR = artifact("mc.jar");

    78             S_DESCR_JAR_NAME);

    82     private static final Path MCS_JAR = artifact("mcs.jar");

    79     private static final Path MS_JAR = S_ARTIFACTS_DIR.resolve(MS_JAR_NAME);

    83     private static final Path AMC_JAR = artifact("amc.jar");

    80     private static final Path MS_WITH_DESCR_JAR = S_ARTIFACTS_DIR.resolve(

    84     private static final Path AMCS_JAR = artifact("amcs.jar");

    81             MS_DESCR_JAR_NAME);

    85 

    82 

    86     private final String unnL;

    83     private static final Path C_ARTIFACTS_DIR = ARTIFACTS_DIR.resolve(C_PKG);

    87     private final String modL;

    84     private static final Path C_JAR = C_ARTIFACTS_DIR.resolve(C_JAR_NAME);

    88     private final String unnC;

    85     private static final Path MC_JAR = C_ARTIFACTS_DIR.resolve(MC_JAR_NAME);

    89     private final String modC;

    86     private static final Path MCN_JAR = C_ARTIFACTS_DIR.resolve(MCN_JAR_NAME);

    90     private final String autoMC;

    87 

    91     // Common set of VM arguments used in all test cases

    88     private static final String MAIN = C_PKG + ".JaasClient";

    92     private final List<String> commonArgs;

    89     private static final String S_INTERFACE

    93 

    90             = "javax.security.auth.spi.LoginModule";

    94     public JaasModularClientTest(boolean service) {

    91     private static final String S_IMPL = S_PKG + ".TestLoginModule";

    95 

    92     private static final List<String> M_REQUIRED = Arrays.asList("java.base",

    96         System.out.printf("%n*** Login Module defined as service in "

    93             "jdk.security.auth");

    97                 + "module-info: %s ***%n%n", service);

    94     private static final Path META_DESCR_PATH = Paths.get("META-INF")

    98         List<String> argList = new LinkedList<>();

    95             .resolve("services").resolve(S_INTERFACE);

    99         argList.add("-Djava.security.auth.login.config="

    96     private static final Path S_META_DESCR_FPATH = S_WITH_META_DESCR_BUILD_DIR

   100                 + toAbsPath(SRC.resolve("jaas.conf")));

    97             .resolve(META_DESCR_PATH);

   101         commonArgs = Collections.unmodifiableList(argList);

    98 

   102 

    99     private static final boolean WITH_S_DESCR = true;

   103         // Based on Testcase, select unnamed/modular jar files to use.

   100     private static final boolean WITHOUT_S_DESCR = false;

   104         unnL = toAbsPath(L_JAR);

   101     private static final String NO_FAILURE = null;

   105         modL = toAbsPath(service ? MSL_JAR : ML_JAR);

   102 

   106         unnC = toAbsPath(C_JAR);

   103     /**

   107         modC = toAbsPath(service ? MCS_JAR : MC_JAR);

   104      * Generates Test specific input parameters.

   108         autoMC = toAbsPath(service ? AMCS_JAR : AMC_JAR);

   105      */

   109     }

   106     @Override

   110 

   107     public Object[][] getTestInput() {

   111     /*

   108 

   112      * Test cases are based on the following logic,

   109         List<List<Object>> params = new ArrayList<>();

   113      * for (definedAs : {"Service in module-info", "Class Type"}) {

   110         String[] args = new String[]{};

   114      *     for (clientType : {"NAMED", "AUTOMATIC", "UNNAMED"}) {

   111         // PARAMETER ORDERS -

   115      *         for (loginModuleType : {"NAMED", "AUTOMATIC", "UNNAMED"}) {

   112         // Client Module Type, Service Module Type,

   116      *             Create and run java command for each possible case

   113         // If Service META descriptor Required,

   117      *         }

   114         // Expected Failure message, Client arguments

   118      *     }

   115         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.EXPLICIT,

   119      * }

   116                 WITH_S_DESCR, NO_FAILURE, args));

   120      */

   117         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.EXPLICIT,

   121     public static void main(String[] args) throws Exception {

   118                 WITHOUT_S_DESCR, NO_FAILURE, args));

   122 

   119         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.AUTO,

   123         // Generates unnamed and modular jars.

   120                 WITH_S_DESCR, NO_FAILURE, args));

   124         setUp();

   121         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.AUTO,

   125         boolean service = Boolean.valueOf(args[0]);

   122                 WITHOUT_S_DESCR, NO_FAILURE, args));

   126         JaasModularClientTest test = new JaasModularClientTest(service);

   123         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.UNNAMED,

   127         test.process();

   124                 WITH_S_DESCR, NO_FAILURE, args));

   128     }

   125         params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.UNNAMED,

   129 

   126                 WITHOUT_S_DESCR, NO_FAILURE, args));

   130     private void process() throws Exception {

   127 

   131 

   128         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.EXPLICIT,

   132         // Case: NAMED-NAMED, NAMED-AUTOMATIC, NAMED-UNNAMED

   129                 WITH_S_DESCR, NO_FAILURE, args));

   133         System.out.println("Case: Modular Client and Modular Login module.");

   130         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.EXPLICIT,

   134         execute(String.format("--module-path %s%s%s -m mc/%s",

   131                 WITHOUT_S_DESCR, NO_FAILURE, args));

   135                 modC, PS, modL, C_TYPE));

   132         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.AUTO,

   136         System.out.println("Case: Modular Client and automatic Login module.");

   133                 WITH_S_DESCR, NO_FAILURE, args));

   137         execute(String.format("--module-path %s%s%s --add-modules=l -m mc/%s",

   134         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.AUTO,

   138                 autoMC, PS, unnL, C_TYPE));

   135                 WITHOUT_S_DESCR, NO_FAILURE, args));

   139         System.out.println("Case: Modular Client and unnamed Login module.");

   136         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.UNNAMED,

   140         execute(String.format("--module-path %s -cp %s -m mc/%s", autoMC,

   137                 WITH_S_DESCR, NO_FAILURE, args));

   141                 unnL, C_TYPE));

   138         params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.UNNAMED,

   142 

   139                 WITHOUT_S_DESCR, NO_FAILURE, args));

   143         // Case: AUTOMATIC-NAMED, AUTOMATIC-AUTOMATIC, AUTOMATIC-UNNAMED

   140 

   144         System.out.println("Case: Automatic Client and modular Login module.");

   141         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.EXPLICIT,

   145         execute(String.format("--module-path %s%s%s --add-modules=ml -m c/%s",

   142                 WITH_S_DESCR, NO_FAILURE, args));

   146                 unnC, PS, modL, C_TYPE));

   143         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.EXPLICIT,

   147         System.out.println("Case: Automatic Client and automatic Login module");

   144                 WITHOUT_S_DESCR, NO_FAILURE, args));

   148         execute(String.format("--module-path %s%s%s --add-modules=l -m c/%s",

   145         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.AUTO,

   149                 unnC, PS, unnL, C_TYPE));

   146                 WITH_S_DESCR, NO_FAILURE, args));

   150         System.out.println("Case: Automatic Client and unnamed Login module.");

   147         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.AUTO,

   151         execute(String.format("--module-path %s -cp %s -m c/%s", unnC,

   148                 WITHOUT_S_DESCR, NO_FAILURE, args));

   152                 unnL, C_TYPE));

   149         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.UNNAMED,

   153 

   150                 WITH_S_DESCR, NO_FAILURE, args));

   154         // Case: UNNAMED-NAMED, UNNAMED-AUTOMATIC, UNNAMED-UNNAMED

   151         params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.UNNAMED,

   155         System.out.println("Case: Unnamed Client and modular Login module.");

   152                 WITHOUT_S_DESCR, NO_FAILURE, args));

   156         execute(String.format("-cp %s --module-path %s --add-modules=ml %s",

   153         return params.stream().map(p -> p.toArray()).toArray(Object[][]::new);

   157                 unnC, modL, C_TYPE));

   154     }

   158         System.out.println("Case: Unnamed Client and automatic Login module.");

   155 

   159         execute(String.format("-cp %s --module-path %s --add-modules=l %s",

   156     /**

   160                 unnC, unnL, C_TYPE));

   157      * Pre-compile and generate the artifacts required to run this test before

   161         System.out.println("Case: Unnamed Client and unnamed Login module.");

   158      * running each test cases.

   162         execute(String.format("-cp %s%s%s %s", unnC, PS, unnL, C_TYPE));

   159      */

   163 

   160     @BeforeTest

   164         // Case: unnamed jars in --module-path and modular jars in -cp.

   161     public void buildArtifacts() {

   165         System.out.println(

   162 

   166                 "Case: Unnamed Client and Login module from modulepath.");

   163         boolean done = true;

   167         execute(String.format("--module-path %s%s%s --add-modules=l -m c/%s",

   164         try {

   168                 unnC, PS, unnL, C_TYPE));

   165             done = CompilerUtils.compile(S_SRC, S_BUILD_DIR);

   169         System.out.println(

   166             done &= CompilerUtils.compile(S_SRC, S_WITH_META_DESCR_BUILD_DIR);

   170                 "Case: Modular Client and Login module in classpath.");

   167             done &= createMetaInfServiceDescriptor(S_META_DESCR_FPATH, S_IMPL);

   171         execute(String.format("-cp %s%s%s %s", modC, PS, modL, C_TYPE));

   168             // Generate modular/regular jars with(out) META-INF

   172     }

   169             // service descriptor

   173 

   170             generateJar(true, MODULE_TYPE.EXPLICIT, MS_JAR, S_BUILD_DIR, false);

   174     /**

   171             generateJar(true, MODULE_TYPE.EXPLICIT, MS_WITH_DESCR_JAR,

   175      * Execute with command arguments and process the result.

   172                     S_WITH_META_DESCR_BUILD_DIR, false);

   176      */

   173             generateJar(true, MODULE_TYPE.UNNAMED, S_JAR, S_BUILD_DIR, false);

   177     private void execute(String args) throws Exception {

   174             generateJar(true, MODULE_TYPE.UNNAMED, S_WITH_DESCRIPTOR_JAR,

   178 

   175                     S_WITH_META_DESCR_BUILD_DIR, false);

   179         String[] safeArgs = Stream.concat(commonArgs.stream(),

   176             // Compile client source codes.

   180                 Stream.of(args.split("\\s+"))).filter(s -> {

   177             done &= CompilerUtils.compile(C_SRC, C_BLD_DIR);

   181             if (s.contains(" ")) {

   178             // Generate modular client jar with explicit dependency

   182                 throw new RuntimeException("No spaces in args");

   179             generateJar(false, MODULE_TYPE.EXPLICIT, MC_JAR, C_BLD_DIR, true);

   180             // Generate modular client jar without any dependency

   181             generateJar(false, MODULE_TYPE.EXPLICIT, MCN_JAR, C_BLD_DIR, false);

   182             // Generate regular client jar

   183             generateJar(false, MODULE_TYPE.UNNAMED, C_JAR, C_BLD_DIR, false);

   184             System.out.format("%nArtifacts generated successfully? %s", done);

   185             if (!done) {

   186                 throw new RuntimeException("Artifact generation failed");

   188         } catch (IOException e) {

   184             return !s.isEmpty();

   189             throw new RuntimeException(e);

   185         }).toArray(String[]::new);

   186         OutputAnalyzer out = ProcessTools.executeTestJvm(safeArgs);

   187         // Handle response.

   188         if (out.getExitValue() != 0) {

   189             System.out.printf("OUTPUT: %s", out.getOutput());

   190             throw new RuntimeException("FAIL: Unknown failure occured.");

   191         } else {

   192             System.out.println("Passed.");

   194      * Generate modular/regular jar based on module type for this test.

   197      * Creates Unnamed/modular jar files for TestClient and TestClassLoader.

   195      */

   198      */

   196     private void generateJar(boolean isService, MODULE_TYPE moduleType,

   199     private static void setUp() throws Exception {

   197             Path jar, Path compilePath, boolean depends) throws IOException {

   200 

   198 

   201         if (ARTIFACT_DIR.toFile().exists()) {

   199         ModuleDescriptor mDescriptor = null;

   202             System.out.println("Skipping setup: Artifacts already exists.");

   200         if (isService) {

   203             return;

   201             mDescriptor = generateModuleDescriptor(isService, moduleType, S_PKG,

   202                     S_PKG, S_INTERFACE, S_IMPL, null, M_REQUIRED, depends);

   203         } else {

   204             mDescriptor = generateModuleDescriptor(isService, moduleType, C_PKG,

   205                     C_PKG, S_INTERFACE, null, S_PKG, M_REQUIRED, depends);

   207         generateJar(mDescriptor, jar, compilePath);

   205         // Generate unnamed login module jar file.

   208     }

   206         JarUtils.createJarFile(L_JAR, TEST_CLASSES,

   209 

   207                 "login/TestLoginModule.class");

   210     /**

   208         // Generate unnamed client jar.

   211      * Holds Logic for the test client. This method will get called with each

   209         JarUtils.createJarFile(C_JAR, TEST_CLASSES, "client/JaasClient.class",

   212      * test parameter.

   210                 "client/JaasClient$MyCallbackHandler.class");

   213      */

   211 

   214     @Override

   212         Builder mBuilder = ModuleDescriptor.newModule("ml")

   215     public OutputAnalyzer executeTestClient(MODULE_TYPE cModuleType,

   213                 .requires("jdk.security.auth");

   216             Path cJarPath, MODULE_TYPE sModuletype, Path sJarPath,

   214         // Modular jar exports package to let the login module type accessible.

   217             String... args) throws Exception {

   215         generateJar(L_JAR, ML_JAR, mBuilder.exports("login").build());

   218 

   216 

   219         OutputAnalyzer output = null;

   217         mBuilder = ModuleDescriptor.newModule("ml")

   220         try {

   218                 .requires("jdk.security.auth")

   221             // For automated/explicit module types, copy the corresponding

   219                 .provides("javax.security.auth.spi.LoginModule",

   222             // jars to module base folder, which will be considered as

   220                         Arrays.asList(L_TYPE));

   223             // module base path during execution.

   221         // Modular login module as Service in module-info does not need to

   224             if (!(cModuleType == MODULE_TYPE.UNNAMED

   222         // export service package.

   225                     && sModuletype == MODULE_TYPE.UNNAMED)) {

   223         generateJar(L_JAR, MSL_JAR, mBuilder.build());

   226                 copyJarsToModuleBase(cModuleType, cJarPath, M_BASE_PATH);

   224 

   227                 copyJarsToModuleBase(sModuletype, sJarPath, M_BASE_PATH);

   225         mBuilder = ModuleDescriptor.newModule("mc").exports("client")

   226                 .requires("jdk.security.auth");

   227         // Generate modular client jar to use automatic login module jar.

   228         generateJar(C_JAR, AMC_JAR, mBuilder.build());

   229         // Generate modular client jar to use modular login module jar.

   230         generateJar(C_JAR, MC_JAR, mBuilder.requires("ml").build());

   231 

   232         mBuilder = ModuleDescriptor.newModule("mc").exports("client")

   233                 .requires("jdk.security.auth")

   234                 .uses("javax.security.auth.spi.LoginModule");

   235         // Generate modular client jar to use automatic login module service.

   236         generateJar(C_JAR, AMCS_JAR, mBuilder.build());

   237         // Generate modular client jar using modular login module service.

   238         generateJar(C_JAR, MCS_JAR, mBuilder.requires("ml").build());

   239     }

   240 

   241     /**

   242      * Update Unnamed jars and include module descriptor files.

   243      */

   244     private static void generateJar(Path sjar, Path djar,

   245             ModuleDescriptor mDesc) throws Exception {

   246 

   247         Files.copy(sjar, djar, StandardCopyOption.REPLACE_EXISTING);

   248         Path dir = Files.createTempDirectory("tmp");

   249         if (mDesc != null) {

   250             Path mi = dir.resolve("module-info.class");

   251             try (OutputStream out = Files.newOutputStream(mi)) {

   252                 ModuleInfoWriter.write(mDesc, out);

   229 

   254             System.out.format("Added 'module-info.class' in '%s'%n", djar);

   230             System.out.format("%nExecuting java client with required"

   231                     + " custom service in class/module path.");

   232             String mName = getModuleName(cModuleType, cJarPath, C_PKG);

   233             Path cmBasePath = (cModuleType != MODULE_TYPE.UNNAMED

   234                     || sModuletype != MODULE_TYPE.UNNAMED) ? M_BASE_PATH : null;

   235             String cPath = buildClassPath(cModuleType, cJarPath, sModuletype,

   236                     sJarPath);

   237             Map<String, String> vmArgs = getVMArgs(sModuletype,

   238                     getModuleName(sModuletype, sJarPath, S_PKG));

   239             output = ProcessTools.executeTestJava(

   240                     getJavaCommand(cmBasePath, cPath, mName, MAIN, vmArgs,

   241                             args)).outputTo(System.out).errorTo(System.out);

   242         } finally {

   243             // Clean module path to hold required jars for next run.

   244             cleanModuleBasePath(M_BASE_PATH);

   246         return output;

   256         JarUtils.updateJarFile(djar, dir);

   247     }

   257     }

   248 

   258 

   249     /**

   259     /**

   250      * Decide the pre-generated client/service jar path for each test case

   260      * Look for file path in generated jars.

   251      * based on client/service module type.

   261      */

   252      */

   262     private static Path artifact(String file) {

   253     @Override

   263         return ARTIFACT_DIR.resolve(file);

   254     public Path findJarPath(boolean isService, MODULE_TYPE moduleType,

   264     }

   255             boolean addMetaDesc, boolean dependsOnServiceModule) {

   265 

   256         if (isService) {

   266     /**

   257             if (moduleType == MODULE_TYPE.EXPLICIT) {

   267      * Convert to absolute file path.

   258                 if (addMetaDesc) {

   268      */

   259                     return MS_WITH_DESCR_JAR;

   269     private static String toAbsPath(Path path) {

   260                 } else {

   270         return path.toFile().getAbsolutePath();

   261                     return MS_JAR;

   271     }

   262                 }

   263             } else {

   264                 if (addMetaDesc) {

   265                     return S_WITH_DESCRIPTOR_JAR;

   266                 } else {

   267                     return S_JAR;

   268                 }

   269             }

   270         } else {

   271             // Choose corresponding client jar using dependent module

   272             if (moduleType == MODULE_TYPE.EXPLICIT) {

   273                 if (dependsOnServiceModule) {

   274                     return MC_JAR;

   275                 } else {

   276                     return MCN_JAR;

   277                 }

   278             } else {

   279                 return C_JAR;

   280             }

   281         }

   282     }

   283 

   284     /**

   285      * VM argument required for the test.

   286      */

   287     private Map<String, String> getVMArgs(MODULE_TYPE sModuletype,

   288             String addModName) throws IOException {

   289         final Map<String, String> vmArgs = new LinkedHashMap<>();

   290         vmArgs.put("-Duser.language=", "en");

   291         vmArgs.put("-Duser.region=", "US");

   292         vmArgs.put("-Djava.security.auth.login.config=", SRC.resolve(

   293                 "jaas.conf").toFile().getCanonicalPath());

   294         if (addModName != null && sModuletype == MODULE_TYPE.AUTO) {

   295             vmArgs.put("--add-modules ", addModName);

   296         }

   297         return vmArgs;

   298     }

   299