1 /*
   2  * Copyright (c) 2011, 2013, 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 7029048
  27  * @summary Checks for LD_LIBRARY_PATH on *nixes
  28  * @compile -XDignore.symbol.file ExecutionEnvironment.java Test7029048.java
  29  * @run main Test7029048
  30  */
  31 
  32 /*
  33  * 7029048: test for LD_LIBRARY_PATH set to different paths which may or
  34  * may not contain a libjvm.so, but we test to ensure that the launcher
  35  * behaves correctly in all cases.
  36  */
  37 import java.io.File;
  38 import java.io.IOException;
  39 import java.nio.file.Files;
  40 import java.util.ArrayList;
  41 import java.util.HashMap;
  42 import java.util.List;
  43 import java.util.Map;
  44 
  45 public class Test7029048 extends TestHelper {
  46 
  47     static int passes = 0;
  48     static int errors = 0;
  49 
  50     private static final String LIBJVM = ExecutionEnvironment.LIBJVM;
  51     private static final String LD_LIBRARY_PATH =
  52             ExecutionEnvironment.LD_LIBRARY_PATH;
  53     private static final String LD_LIBRARY_PATH_64 =
  54             ExecutionEnvironment.LD_LIBRARY_PATH_64;
  55 
  56     private static final File libDir =
  57             new File(System.getProperty("sun.boot.library.path"));
  58     private static final File srcServerDir = new File(libDir, "server");
  59     private static final File srcLibjvmSo = new File(srcServerDir, LIBJVM);
  60 
  61     private static final File dstLibDir = new File("lib");
  62     private static final File dstLibArchDir =
  63             new File(dstLibDir, getJreArch());
  64 
  65     private static final File dstServerDir = new File(dstLibArchDir, "server");
  66     private static final File dstServerLibjvm = new File(dstServerDir, LIBJVM);
  67 
  68     private static final File dstClientDir = new File(dstLibArchDir, "client");
  69     private static final File dstClientLibjvm = new File(dstClientDir, LIBJVM);
  70 
  71     private static final Map<String, String> env = new HashMap<>();
  72 
  73 
  74     static String getValue(String name, List<String> in) {
  75         for (String x : in) {
  76             String[] s = x.split("=");
  77             if (name.equals(s[0].trim())) {
  78                 return s[1].trim();
  79             }
  80         }
  81         return null;
  82     }
  83 
  84     static void run(Map<String, String> env,
  85             int nLLPComponents, String caseID) {
  86         env.put(ExecutionEnvironment.JLDEBUG_KEY, "true");
  87         List<String> cmdsList = new ArrayList<>();
  88         cmdsList.add(javaCmd);
  89         cmdsList.add("-server");
  90         cmdsList.add("-jar");
  91         cmdsList.add(ExecutionEnvironment.testJarFile.getAbsolutePath());
  92         String[] cmds = new String[cmdsList.size()];
  93         TestResult tr = doExec(env, cmdsList.toArray(cmds));
  94         System.out.println(tr);
  95         analyze(tr, nLLPComponents, caseID);
  96     }
  97 
  98     static void analyze(TestResult tr, int nLLPComponents, String caseID) {
  99         String envValue = getValue(LD_LIBRARY_PATH, tr.testOutput);
 100        /*
 101         * the envValue can never be null, since the test code should always
 102         * print a "null" string.
 103         */
 104         if (envValue == null) {
 105             System.out.println(tr);
 106             throw new RuntimeException("NPE, likely a program crash ??");
 107         }
 108         String values[] = envValue.split(File.pathSeparator);
 109         if (values.length == nLLPComponents) {
 110             System.out.println(caseID + " :OK");
 111             passes++;
 112         } else {
 113             System.out.println("FAIL: test7029048, " + caseID);
 114             System.out.println(" expected " + nLLPComponents
 115                     + " but got " + values.length);
 116             System.out.println(envValue);
 117             System.out.println(tr);
 118             errors++;
 119         }
 120     }
 121 
 122     /*
 123      * A crucial piece, specifies what we should expect, given the conditions.
 124      * That is for a given enum type, the value indicates how many absolute
 125      * environment variables that can be expected. This value is used to base
 126      * the actual expected values by adding the set environment variable usually
 127      * it is 1, but it could be more if the test wishes to set more paths in
 128      * the future.
 129      */
 130     private static enum LLP_VAR {
 131         LLP_SET_NON_EXISTENT_PATH(0),   // env set, but the path does not exist
 132         LLP_SET_EMPTY_PATH(0),          // env set, with a path but no libjvm.so
 133         LLP_SET_WITH_JVM(3);            // env set, with a libjvm.so
 134         private final int value;
 135         LLP_VAR(int i) {
 136             this.value = i;
 137         }
 138     }
 139 
 140     /*
 141      * test for 7029048
 142      */
 143     static void test7029048() throws IOException {
 144         String desc = null;
 145         for (LLP_VAR v : LLP_VAR.values()) {
 146             switch (v) {
 147                 case LLP_SET_WITH_JVM:
 148                     // copy the files into the directory structures
 149                     copyFile(srcLibjvmSo, dstServerLibjvm);
 150                     // does not matter if it is client or a server
 151                     copyFile(srcLibjvmSo, dstClientLibjvm);
 152                     desc = "LD_LIBRARY_PATH should be set";
 153                     break;
 154                 case LLP_SET_EMPTY_PATH:
 155                     if (!dstClientDir.exists()) {
 156                         Files.createDirectories(dstClientDir.toPath());
 157                     } else {
 158                         Files.deleteIfExists(dstClientLibjvm.toPath());
 159                     }
 160 
 161                     if (!dstServerDir.exists()) {
 162                         Files.createDirectories(dstServerDir.toPath());
 163                     } else {
 164                         Files.deleteIfExists(dstServerLibjvm.toPath());
 165                     }
 166 
 167                     desc = "LD_LIBRARY_PATH should not be set";
 168                     break;
 169                 case LLP_SET_NON_EXISTENT_PATH:
 170                     if (dstLibDir.exists()) {
 171                         recursiveDelete(dstLibDir);
 172                     }
 173                     desc = "LD_LIBRARY_PATH should not be set";
 174                     break;
 175                 default:
 176                     throw new RuntimeException("unknown case");
 177             }
 178 
 179             /*
 180              * Case 1: set the server path
 181              */
 182             env.clear();
 183             env.put(LD_LIBRARY_PATH, dstServerDir.getAbsolutePath());
 184             run(env, v.value + 1, "Case 1: " + desc);
 185 
 186             /*
 187              * Case 2: repeat with client path
 188              */
 189             env.clear();
 190             env.put(LD_LIBRARY_PATH, dstClientDir.getAbsolutePath());
 191             run(env, v.value + 1, "Case 2: " + desc);
 192 
 193             if (isSolaris) {
 194                 /*
 195                  * Case 3: set the appropriate LLP_XX flag,
 196                  * java64 -d64, LLP_64 is relevant, LLP_32 is ignored
 197                  */
 198                 env.clear();
 199                 env.put(LD_LIBRARY_PATH_64, dstServerDir.getAbsolutePath());
 200                 run(env, v.value + 1, "Case 3: " + desc);
 201             }
 202         }
 203         return;
 204     }
 205 
 206     public static void main(String... args) throws Exception {
 207         if (TestHelper.isWindows || TestHelper.isMacOSX) {
 208             System.out.println("Note: applicable on neither Windows nor MacOSX");
 209             return;
 210         }
 211         if (!TestHelper.haveServerVM) {
 212             System.out.println("Note: test relies on server vm, not found, exiting");
 213             return;
 214         }
 215         // create our test jar first
 216         ExecutionEnvironment.createTestJar();
 217 
 218         // run the tests
 219         test7029048();
 220         if (errors > 0) {
 221             throw new Exception("Test7029048: FAIL: with "
 222                     + errors + " errors and passes " + passes);
 223         } else if (isSolaris && passes < 9) {
 224             throw new Exception("Test7029048: FAIL: " +
 225                     "all tests did not run, expected " + 9 + " got " + passes);
 226         } else if (isLinux && passes < 6) {
 227              throw new Exception("Test7029048: FAIL: " +
 228                     "all tests did not run, expected " + 6 + " got " + passes);
 229         } else {
 230             System.out.println("Test7029048: PASS " + passes);
 231         }
 232     }
 233 }