Java example source code file (TestBug4179766.java)

This example Java source code file (TestBug4179766.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

bug4179766class, bug4179766resource, class, classloader, classnotfoundexception, exception, fileinputstream, illegalaccessexception, loader, object, resourcebundle, returning, same_hash_code, string, util

The TestBug4179766.java Java example source code

/*
 * Copyright (c) 2007, 2010, 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.
 */
/*
    @test  1.3 99/02/15
    @summary test Resource Bundle for bug 4179766
    @build Bug4179766Class Bug4179766Resource Bug4179766Getter
    @run main TestBug4179766
    @bug 4179766
*/
/*
 *
 *
 * (C) Copyright IBM Corp. 1996 - 1999 - All Rights Reserved
 *
 * Portions copyright (c) 2007 Sun Microsystems, Inc.
 * All Rights Reserved.
 *
 * The original version of this source code and documentation
 * is copyrighted and owned by Taligent, Inc., a wholly-owned
 * subsidiary of IBM. These materials are provided under terms
 * of a License Agreement between Taligent and Sun. This technology
 * is protected by multiple US and International patents.
 *
 * This notice and attribution to Taligent may not be removed.
 * Taligent is a registered trademark of Taligent, Inc.
 *
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for NON-COMMERCIAL purposes and without
 * fee is hereby granted provided that this copyright notice
 * appears in all copies. Please refer to the file "copyright.html"
 * for further important copyright and licensing information.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 *
 */

import java.util.Hashtable;
import java.util.ResourceBundle;
import java.util.MissingResourceException;
import java.util.Hashtable;
import java.io.File;
import java.io.FileInputStream;

/**
 * This class tests the behavior of the ResourceBundle cache with
 * respect to ClassLoaders.  The same resource loaded by different
 * loaders should be cached as separate objects, one for each loader.
 * In order to test this behavior, this test constructs a custom
 * class loader to load its resources.  It does not delegate resource
 * loading to the system loader to load the class files, but loads
 * them from the current directory instead.  This is so that the
 * defining class loader for the resources is different.  If it
 * delegated to the system loader to load the resources, the
 * defining ClassLoader would be the same even though the initiating
 * loader differered, and the resource would only be cached once.
 */
public class TestBug4179766 extends RBTestFmwk {
    //hash code used by class loaders when sameHash is true
    private static final int SAME_HASH_CODE = 0;
    //the next unique hash code
    private static int nextHashCode = SAME_HASH_CODE + 1;
    //suffix on class files
    private static final String CLASS_SUFFIX = ".class";

    //generate a unique hashcode for a class loader
    private static synchronized int getNextHashCode() {
        return nextHashCode++;
    }

    public static void main(String[] args) throws Exception {
        //static links so all needed classes get compiled
        Object o1 = new Bug4179766Class();
        Object o2 = new Bug4179766Resource();
        new TestBug4179766().run(args);
    }

    /**
    * Ensure the resource cache is working correctly for a single
    * resource from a single loader.  If we get the same resource
    * from the same loader twice, we should get the same resource.
    */
    public void testCache() throws Exception {
        Loader loader = new Loader(false);
        ResourceBundle b1 = getResourceBundle(loader, "Bug4179766Resource");
        if (b1 == null) {
            errln("Resource not found: Bug4179766Resource");
        }
        ResourceBundle b2 = getResourceBundle(loader, "Bug4179766Resource");
        if (b2 == null) {
            errln("Resource not found: Bug4179766Resource");
        }
        printIDInfo("[bundle1]",b1);
        printIDInfo("[bundle2]",b2);
        if (b1 != b2) {
            errln("Different objects returned by same ClassLoader");
        }
    }

    /**
    * Test that loaders with the same hash key still
    * cache resources seperately
    */
    public void testSameHash() throws Exception {
        doTest(true);
    }

    /**
    * Test that loaders with different hash keys
    * cache resources seperately
    */
    public void testDifferentHash() throws Exception {
        doTest(false);
    }

    /**
     * Ensure that cached resources for different ClassLoaders
     * are cached seperately
     */
    private void doTest(boolean sameHash) throws Exception {
        ResourceBundle b1 = getResourceBundle(new Loader(sameHash), "Bug4179766Resource");
        if (b1 == null) {
           errln("Resource not found: Bug4179766Resource");
        }
        ResourceBundle b2 = getResourceBundle(new Loader(sameHash), "Bug4179766Resource");
        if (b2 == null) {
           errln("Resource not found: Bug4179766Resource");
        }
        printIDInfo("[bundle1]",b1);
        printIDInfo("[bundle2]",b2);
        if (b1 == b2) {
           errln("Same object returned by different ClassLoaders");
        }
    }

    /**
     * Get a resource using a specified class loader to load the resource
     */
    private ResourceBundle getResourceBundle(Loader loader, String name) throws Exception {
        try {
            Class c = loader.loadClass("Bug4179766Class");
            Bug4179766Getter test = (Bug4179766Getter)c.newInstance();
            return test.getResourceBundle(name);
        } catch (ClassNotFoundException e) {
            errln("Class not found by custom class loader: "+name);
            throw e;
        } catch (InstantiationException e) {
            errln("Error instantiating: "+name);
            throw e;
        } catch (IllegalAccessException e) {
            errln("IllegalAccessException instantiating: "+name);
            throw e;
        }
    }

    /**
     * Print information about an object
     * [message][object's identity][object's class][object's loader][loaders hash][loaders identity]
     */
    private void printIDInfo(String message, Object o) {
        if (o == null) {
            return;
        }
        Class c = o.getClass();
        ClassLoader l = c.getClassLoader();
        int hash = -1;
        if (l != null) {
            hash = l.hashCode();
        }
        logln(message + System.identityHashCode(o) + "  Class: " + c
                + "  ClassLoader: " + l + "  loaderHash: " + hash
                + "  loaderPrimHash: " + System.identityHashCode(l));
    }

    /**
     * A simple class loader that loads classes from the current
     * working directory.  The hash code of the loader can be
     * set to be either the loaders identity or 0, allowing several
     * loaders to have the same hashCode value.
     */
    public class Loader extends ClassLoader {
        private int thisHashCode;

        /**
         * Create a new loader
         */
        public Loader(boolean sameHash) {
            super(Loader.class.getClassLoader());
            if (sameHash) {
                thisHashCode = SAME_HASH_CODE;
            } else {
                thisHashCode = getNextHashCode();
            }
        }

        /**
         * Return the hash code for this loader.
         */
        public int hashCode() {
            return thisHashCode;
        }

        /**
         * Get the data from the class file for the specified class.  If
         * the file can't be found, or the class is not one of the
         * special ones listed below, return null.
         *    Bug4179766Class
         *    Bug4179766Resource
         */
        private byte[] getClassData(String className) {
            boolean shouldLoad = className.equals("Bug4179766Class");
            shouldLoad = shouldLoad || className.equals("Bug4179766Resource");

            if (shouldLoad) {
                try {
                    File file = new File(System.getProperty("test.classes", "."), className+CLASS_SUFFIX);
                    FileInputStream fi = new FileInputStream(file);
                    byte[] result = new byte[fi.available()];
                    fi.read(result);
                    return result;
                } catch (Exception e) {
                    return null;
                }
            } else {
                return null;
            }
        }

        /**
         * Load a class.  Files we can load take preference over ones the system
         * can load.
         */
        public synchronized Class loadClass(String className, boolean resolveIt)
                throws ClassNotFoundException {

            Class result = findLoadedClass(className);
            if (result != null) {
                printInfo("        ***Returning cached class: "+className, result);
                return result;
            }

            byte[] classData = getClassData(className);
            if (classData == null) {
                //we don't have a local copy of this one
                return loadFromSystem(className);
            }

            result = defineClass(classData, 0, classData.length);
            if (result == null) {
                //there was an error defining the class
                return loadFromSystem(className);
            }

            if (resolveIt) {
                resolveClass(result);
            }

            printInfo("        ***Loaded local class: "+className, result);
            return result;
        }

        /**
         * Delegate loading to the system loader
         */
        private Class loadFromSystem(String className) throws ClassNotFoundException {
            try {
                Class result = getParent().loadClass(className);
                printInfo("        ***Returning system class: "+className, result);
                return result;
            } catch (ClassNotFoundException e) {
                printInfo("        ***Class not found: "+className, null);
                throw e;
            }
        }

        /**
         * Print information about a class that was loaded
         * [loader identity][message][class identity]
         */
        private void printInfo(String message, Class c) {
            if (c != null) {
                logln(""+System.identityHashCode(this)+"  "+message+"  "+System.identityHashCode(c));
            } else {
                logln(""+System.identityHashCode(this)+"  "+message);
            }
        }
    }
}