Java example source code file (IndirectlyLoadABundle.java)

This example Java source code file (IndirectlyLoadABundle.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

callersearchableresource, exception, indirectlyloadabundle, invocationtargetexception, loaditup1, log, logger, logging, method, nestedlogger1, nestedlogger2, net, network, object, reflection, string, test, throwable, urlclassloader

The IndirectlyLoadABundle.java Java example source code

/*
 * Copyright (c) 2013, 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.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Paths;
import java.util.logging.Logger;

/**
 * This class is used to ensure that a resource bundle loadable by a classloader
 * is on the caller's stack, but not on the classpath or TCCL.  It tests that
 * Logger.getLogger() can load the bundle via the immediate caller's classloader
 *
 * @author Jim Gish
 */
public class IndirectlyLoadABundle {

    private final static String rbName = "CallerSearchableResource";

    public boolean loadAndTest() throws Throwable {
        // Make sure we can find it via the URLClassLoader
        URLClassLoader yetAnotherResourceCL = new URLClassLoader(getURLs(), null);
        if (!testForValidResourceSetup(yetAnotherResourceCL)) {
            throw new Exception("Couldn't directly load bundle " + rbName
                    + " as expected. Test config problem");
        }
        // But it shouldn't be available via the system classloader
        ClassLoader myCL = this.getClass().getClassLoader();
        if (testForValidResourceSetup(myCL)) {
            throw new Exception("Was able to directly load bundle " + rbName
                    + " from " + myCL + " but shouldn't have been"
                    + " able to. Test config problem");
        }

        Class<?> loadItUpClazz = Class.forName("LoadItUp1", true,
                                               yetAnotherResourceCL);
        ClassLoader actual = loadItUpClazz.getClassLoader();
        if (actual != yetAnotherResourceCL) {
            throw new Exception("LoadItUp1 was loaded by an unexpected CL: " + actual);
        }
        Object loadItUp = loadItUpClazz.newInstance();
        Method testMethod = loadItUpClazz.getMethod("getLogger", String.class, String.class);
        try {
            return (Logger)testMethod.invoke(loadItUp, "NestedLogger1", rbName) != null;
        } catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }

    public boolean testGetAnonymousLogger() throws Throwable {
        // Test getAnonymousLogger()
        URLClassLoader loadItUpCL = new URLClassLoader(getURLs(), null);
        Class<?> loadItUpClazz = Class.forName("LoadItUp1", true, loadItUpCL);
        ClassLoader actual = loadItUpClazz.getClassLoader();
        if (actual != loadItUpCL) {
            throw new Exception("LoadItUp1 was loaded by an unexpected CL: "
                                 + actual);
        }
        Object loadItUpAnon = loadItUpClazz.newInstance();
        Method testAnonMethod = loadItUpClazz.getMethod("getAnonymousLogger",
                                                        String.class);
        try {
            return (Logger)testAnonMethod.invoke(loadItUpAnon, rbName) != null;
        } catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }


    public boolean testGetLoggerGetLoggerWithBundle() throws Throwable {
        // test getLogger("NestedLogger2"); followed by
        // getLogger("NestedLogger2", rbName) to see if the bundle is found
        //
        URL[] urls = getURLs();
        if (getLoggerWithNewCL(urls, "NestedLogger2", null)) {
            return getLoggerWithNewCL(urls, "NestedLogger2", rbName);

        } else {
            throw new Exception("TEST FAILED: first call to getLogger() failed "
                                 + " in IndirectlyLoadABundle."
                                 + "testGetLoggerGetLoggerWithBundle");
        }
    }

    private URL[] getURLs() throws MalformedURLException {
        // Find out where we are running from so we can setup the URLClassLoader URLs
        // test.src and test.classes will be set if running in jtreg, but probably
        // not otherwise
        String testDir = System.getProperty("test.src", System.getProperty("user.dir"));
        String testClassesDir = System.getProperty("test.classes",
                                                   System.getProperty("user.dir"));
        URL[] urls = new URL[2];
        // Allow for both jtreg and standalone cases here
        urls[0] = Paths.get(testDir, "resources").toUri().toURL();
        urls[1] = Paths.get(testClassesDir).toUri().toURL();

        return urls;
    }

    private boolean getLoggerWithNewCL(URL[] urls, String loggerName,
                                         String bundleName) throws Throwable {
        Logger result = null;;
        // Test getLogger("foo"); getLogger("foo", "rbName");
        // First do the getLogger() call with no bundle name
        URLClassLoader getLoggerCL = new URLClassLoader(urls, null);
        Class<?> loadItUpClazz1 = Class.forName("LoadItUp1", true, getLoggerCL);
        ClassLoader actual = loadItUpClazz1.getClassLoader();
        if (actual != getLoggerCL) {
            throw new Exception("LoadItUp1 was loaded by an unexpected CL: "
                                 + actual);
        }
        Object loadItUp1 = loadItUpClazz1.newInstance();
        if (bundleName != null) {
            Method getLoggerMethod = loadItUpClazz1.getMethod("getLogger",
                                                              String.class,
                                                              String.class);
            try {
                result = (Logger) getLoggerMethod.invoke(loadItUp1, loggerName,
                                                         bundleName);
            } catch (InvocationTargetException ex) {
                throw ex.getTargetException();
            }
        } else {
            Method getLoggerMethod = loadItUpClazz1.getMethod("getLogger",
                                                              String.class);
            try {
                result = (Logger) getLoggerMethod.invoke(loadItUp1, loggerName);
            } catch (InvocationTargetException ex) {
                throw ex.getTargetException();
            }
        }
        return result != null;
    }

    private boolean testForValidResourceSetup(ClassLoader cl) {
        // First make sure the test environment is setup properly and the bundle
        // actually exists
        return ResourceBundleSearchTest.isOnClassPath(rbName, cl);
    }
}