1 /*

     2  * Copyright (c) 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     8002070

    27  * @summary Remove the stack search for a resource bundle Logger to use

    28  * @author  Jim Gish

    29  * @build  ResourceBundleSearchTest IndirectlyLoadABundle LoadItUp

    30  * @run main ResourceBundleSearchTest

    31  */

    32 import java.net.URL;

    33 import java.net.URLClassLoader;

    34 import java.nio.file.Paths;

    35 import java.util.ArrayList;

    36 import java.util.List;

    37 import java.util.Locale;

    38 import java.util.MissingResourceException;

    39 import java.util.ResourceBundle;

    40 import java.util.logging.Logger;

    41 

    42 public class ResourceBundleSearchTest {

    43 

    44     private final static boolean DEBUG = false;

    45     private final static String LOGGER_PREFIX = "myLogger.";

    46     private static int loggerNum = 0;

    47     private final static String PROP_RB_NAME = "ClassPathTestBundle";

    48     private final static String TCCL_TEST_BUNDLE = "ContextClassLoaderTestBundle";

    49 

    50     private static int numPass = 0;

    51     private static int numFail = 0;

    52     private static List<String> msgs = new ArrayList<>();

    53 

    54     public static void main(String[] args) throws Throwable {

    55         ResourceBundleSearchTest test = new ResourceBundleSearchTest();

    56         test.runTests();

    57     }

    58 

    59     private void runTests() throws Throwable {

    60         // ensure we are using en as the default Locale so we can find the resource

    61         Locale.setDefault(Locale.ENGLISH);

    62 

    63         String testClasses = System.getProperty("test.classes");

    64         System.out.println( "test.classes = " + testClasses );

    65 

    66         ClassLoader myClassLoader = ClassLoader.getSystemClassLoader();

    67 

    68         // Find out where we are running from so we can setup the URLClassLoader URL

    69         String userDir = System.getProperty("user.dir");

    70         String testDir = System.getProperty("test.src", userDir);

    71         String sep = System.getProperty("file.separator");

    72 

    73         URL[] urls = new URL[1];

    74 

    75         urls[0] = Paths.get(testDir, "resources").toUri().toURL();

    76         URLClassLoader rbClassLoader = new URLClassLoader(urls);

    77 

    78         // Test 1 - can we find a Logger bundle from doing a stack search?

    79         // We shouldn't be able to

    80         assertFalse(testGetBundleFromStackSearch(), "testGetBundleFromStackSearch");

    81 

    82         // Test 2 - can we find a Logger bundle off of the Thread context class

    83         // loader? We should be able to.

    84         assertTrue(

    85                 testGetBundleFromTCCL(TCCL_TEST_BUNDLE, rbClassLoader),

    86                 "testGetBundleFromTCCL");

    87 

    88         // Test 3 - Can we find a Logger bundle from the classpath?  We should be

    89         // able to, but ....

    90         // We check to see if the bundle is on the classpath or not so that this

    91         // will work standalone.  In the case of jtreg/samevm,

    92         // the resource bundles are not on the classpath.  Running standalone

    93         // (or othervm), they are

    94         if (isOnClassPath(PROP_RB_NAME, myClassLoader)) {

    95             debug("We should be able to see " + PROP_RB_NAME + " on the classpath");

    96             assertTrue(testGetBundleFromSystemClassLoader(PROP_RB_NAME),

    97                     "testGetBundleFromSystemClassLoader");

    98         } else {

    99             debug("We should not be able to see " + PROP_RB_NAME + " on the classpath");

   100             assertFalse(testGetBundleFromSystemClassLoader(PROP_RB_NAME),

   101                     "testGetBundleFromSystemClassLoader");

   102         }

   103 

   104         report();

   105     }

   106 

   107     private void report() throws Exception {

   108         System.out.println("Num passed = " + numPass + " Num failed = " + numFail);

   109         if (numFail > 0) {

   110             // We only care about the messages if they were errors

   111             for (String msg : msgs) {

   112                 System.out.println(msg);

   113             }

   114             throw new Exception(numFail + " out of " + (numPass + numFail)

   115                     + " tests failed.");

   116         }

   117     }

   118 

   119     public void assertTrue(boolean testResult, String testName) {

   120         if (testResult) {

   121             numPass++;

   122         } else {

   123             numFail++;

   124             System.out.println("FAILED: " + testName

   125                     + " was supposed to return true but did NOT!");

   126         }

   127     }

   128 

   129     public void assertFalse(boolean testResult, String testName) {

   130         if (!testResult) {

   131             numPass++;

   132         } else {

   133             numFail++;

   134             System.out.println("FAILED: " + testName

   135                     + " was supposed to return false but did NOT!");

   136         }

   137     }

   138 

   139     public boolean testGetBundleFromStackSearch() throws Throwable {

   140         // This should fail.  This was the old functionality to search up the

   141         // caller's call stack

   142         IndirectlyLoadABundle indirectLoader = new IndirectlyLoadABundle();

   143         return indirectLoader.loadAndTest();

   144     }

   145 

   146     public boolean testGetBundleFromTCCL(String bundleName,

   147             ClassLoader setOnTCCL) throws InterruptedException {

   148         // This should succeed.  We should be able to get the bundle from the

   149         // thread context class loader

   150         debug("Looking for " + bundleName + " using TCCL");

   151         LoggingThread lr = new LoggingThread(bundleName, setOnTCCL);

   152         lr.start();

   153         synchronized (lr) {

   154             try {

   155                 lr.wait();

   156             } catch (InterruptedException ex) {

   157                 throw ex;

   158             }

   159         }

   160         msgs.add(lr.msg);

   161         return lr.foundBundle;

   162     }

   163 

   164     /*

   165      * @param String bundleClass

   166      * @param ClassLoader to use for search

   167      * @return true iff bundleClass is on system classpath

   168      */

   169     public static boolean isOnClassPath(String baseName, ClassLoader cl) {

   170         ResourceBundle rb = null;

   171         try {

   172             rb = ResourceBundle.getBundle(baseName, Locale.getDefault(), cl);

   173             System.out.println("INFO: Found bundle " + baseName + " on " + cl);

   174         } catch (MissingResourceException e) {

   175             System.out.println("INFO: Could not find bundle " + baseName + " on " + cl);

   176             return false;

   177         }

   178         return (rb != null);

   179     }

   180 

   181     private static String newLoggerName() {

   182         // we need a new logger name every time we attempt to find a bundle via

   183         // the Logger.getLogger call, so we'll simply tack on an integer which

   184         // we increment each time this is called

   185         loggerNum++;

   186         return LOGGER_PREFIX + loggerNum;

   187     }

   188 

   189     public boolean testGetBundleFromSystemClassLoader(String bundleName) {

   190         // this should succeed if the bundle is on the system classpath.

   191         try {

   192             Logger aLogger = Logger.getLogger(ResourceBundleSearchTest.newLoggerName(),

   193                     bundleName);

   194         } catch (MissingResourceException re) {

   195             msgs.add("INFO: testGetBundleFromSystemClassLoader() did not find bundle "

   196                     + bundleName);

   197             return false;

   198         }

   199         msgs.add("INFO: testGetBundleFromSystemClassLoader() found the bundle "

   200                 + bundleName);

   201         return true;

   202     }

   203 

   204     public static class LoggingThread extends Thread {

   205 

   206         boolean foundBundle = false;

   207         String msg = null;

   208         ClassLoader clToSetOnTCCL = null;

   209         String bundleName = null;

   210 

   211         public LoggingThread(String bundleName) {

   212             this.bundleName = bundleName;

   213         }

   214 

   215         public LoggingThread(String bundleName, ClassLoader setOnTCCL) {

   216             this.clToSetOnTCCL = setOnTCCL;

   217             this.bundleName = bundleName;

   218         }

   219 

   220         public void run() {

   221             boolean setTCCL = false;

   222             try {

   223                 if (clToSetOnTCCL != null) {

   224                     Thread.currentThread().setContextClassLoader(clToSetOnTCCL);

   225                     setTCCL = true;

   226                 }

   227                 // this should succeed if the bundle is on the system classpath.

   228                 try {

   229                     Logger aLogger = Logger.getLogger(ResourceBundleSearchTest.newLoggerName(),

   230                             bundleName);

   231                     msg = "INFO: LoggingRunnable() found the bundle " + bundleName

   232                             + (setTCCL ? " with " : " without ") + "setting the TCCL";

   233                     foundBundle = true;

   234                 } catch (MissingResourceException re) {

   235                     msg = "INFO: LoggingRunnable() did not find the bundle " + bundleName

   236                             + (setTCCL ? " with " : " without ") + "setting the TCCL";

   237                     foundBundle = false;

   238                 }

   239             } catch (Throwable e) {

   240                 e.printStackTrace();

   241                 System.exit(1);

   242             }

   243         }

   244     }

   245 

   246     private void debug(String msg) {

   247         if (DEBUG) {

   248             System.out.println(msg);

   249         }

   250     }

   251 }