| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.harmony.luni.tests.java.lang; |
| |
| import dalvik.annotation.AndroidOnly; |
| import dalvik.annotation.BrokenTest; |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| import junit.framework.TestCase; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.nio.ByteBuffer; |
| import java.security.CodeSource; |
| import java.security.Permission; |
| import java.security.PermissionCollection; |
| import java.security.Policy; |
| import java.security.ProtectionDomain; |
| import java.util.Enumeration; |
| import java.util.NoSuchElementException; |
| |
| @TestTargetClass(ClassLoader.class) |
| public class ClassLoaderTest extends TestCase { |
| |
| public static volatile int flag; |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "ClassLoader", |
| args = {} |
| ) |
| public void test_ClassLoader() { |
| PublicClassLoader pcl = new PublicClassLoader(); |
| SecurityManager sm = new SecurityManager() { |
| RuntimePermission rp = new RuntimePermission("getProtectionDomain"); |
| |
| public void checkCreateClassLoader() { |
| throw new SecurityException(); |
| } |
| |
| public void checkPermission(Permission perm) { |
| if (perm.equals(rp)) { |
| throw new SecurityException(); |
| } |
| } |
| }; |
| |
| SecurityManager oldSm = System.getSecurityManager(); |
| System.setSecurityManager(sm); |
| try { |
| new PublicClassLoader(); |
| fail("SecurityException should be thrown."); |
| } catch (SecurityException e) { |
| // expected |
| } finally { |
| System.setSecurityManager(oldSm); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "ClassLoader", |
| args = {java.lang.ClassLoader.class} |
| ) |
| @BrokenTest("Infinite loop in classloader. Actually a known failure.") |
| public void test_ClassLoaderLClassLoader() { |
| PublicClassLoader pcl = new PublicClassLoader( |
| ClassLoader.getSystemClassLoader()); |
| assertEquals(ClassLoader.getSystemClassLoader(), pcl.getParent()); |
| |
| SecurityManager sm = new SecurityManager() { |
| RuntimePermission rp = new RuntimePermission("getProtectionDomain"); |
| |
| public void checkCreateClassLoader() { |
| throw new SecurityException(); |
| } |
| |
| public void checkPermission(Permission perm) { |
| if (perm.equals(rp)) { |
| throw new SecurityException(); |
| } |
| } |
| }; |
| |
| SecurityManager oldSm = System.getSecurityManager(); |
| System.setSecurityManager(sm); |
| try { |
| new PublicClassLoader(ClassLoader.getSystemClassLoader()); |
| fail("SecurityException should be thrown."); |
| } catch (SecurityException e) { |
| // expected |
| } finally { |
| System.setSecurityManager(oldSm); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "", |
| method = "clearAssertionStatus", |
| args = {} |
| ) |
| @KnownFailure("Android doesn't support assertions to be activated " + |
| "through the api") |
| public void test_clearAssertionStatus() { |
| String className = getClass().getPackage().getName() + ".TestAssertions"; |
| String className1 = getClass().getPackage().getName() + ".TestAssertions1"; |
| ClassLoader cl = getClass().getClassLoader(); |
| cl.setClassAssertionStatus("TestAssertions", true); |
| cl.setDefaultAssertionStatus(true); |
| try { |
| |
| Class clazz = cl.loadClass(className); |
| |
| TestAssertions ta = (TestAssertions) clazz.newInstance(); |
| try { |
| ta.test(); |
| fail("AssertionError should be thrown."); |
| } catch(AssertionError ae) { |
| //expected |
| } |
| cl.clearAssertionStatus(); |
| clazz = cl.loadClass(className1); |
| |
| TestAssertions1 ta1 = (TestAssertions1) clazz.newInstance(); |
| try { |
| ta1.test(); |
| } catch(AssertionError ae) { |
| fail("AssertionError should not be thrown."); |
| } |
| |
| } catch(Exception cnfe) { |
| fail("Unexpected exception: " + cnfe.toString()); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "This method is not supported. " + |
| "UnsupportedOperationException should be thrown.", |
| method = "defineClass", |
| args = {byte[].class, int.class, int.class} |
| ) |
| @AndroidOnly("define methods re not supported on Android. " + |
| "UnsupportedOperationException should be thrown.") |
| public void test_defineClassLbyteArrayLintLint() throws Exception { |
| |
| try { |
| Class<?> a = new Ldr().define(Ldr.TEST_CASE_DEFINE_1); |
| //assertEquals("org.apache.harmony.luni.tests.java.lang.A", a.getName()); |
| fail("UnsupportedOperationException was not thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| new Ldr().define(1000, Ldr.TEST_CASE_DEFINE_1); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| fail("UnsupportedOperationException should be thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "This method is not supported. UnsupportedOperationException should be thrown.", |
| method = "defineClass", |
| args = {java.lang.String.class, byte[].class, int.class, int.class, java.security.ProtectionDomain.class} |
| ) |
| @AndroidOnly("define methods re not supported on Android. " + |
| "UnsupportedOperationException should be thrown.") |
| public void test_defineClassLjava_lang_StringLbyteArrayLintLintLProtectionDomain() |
| throws Exception { |
| |
| try { |
| Class<?> a = new Ldr().define(Ldr.TEST_CASE_DEFINE_2); |
| //assertEquals("org.apache.harmony.luni.tests.java.lang.A", a.getName()); |
| //assertEquals(getClass().getProtectionDomain(), a.getProtectionDomain()); |
| fail("UnsupportedOperationException was not thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| new Ldr().define(1000, Ldr.TEST_CASE_DEFINE_2); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| fail("UnsupportedOperationException should be thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| /*try { |
| ErrorLdr loader = new ErrorLdr(); |
| |
| try { |
| loader.define("WrongFormatClass", Ldr.TEST_CASE_DEFINE_2); |
| fail("ClassFormatError should be thrown."); |
| } catch (ClassFormatError le) { |
| //expected |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| loader.defineWrongName("TestClass", 0); |
| fail("NoClassDefFoundError should be thrown."); |
| } catch (NoClassDefFoundError ncdfe) { |
| //expected |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| Class<?> clazz = loader.defineNullDomain("TestClass", 0); |
| assertEquals(getClass().getProtectionDomain(), |
| clazz.getProtectionDomain()); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| } catch(Exception e) { |
| fail("Unexpected exception was thrown: " + e.toString()); |
| } |
| */ |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "This method is not supported. UnsupportedOperationException should be thrown.", |
| method = "defineClass", |
| args = {java.lang.String.class, java.nio.ByteBuffer.class, java.security.ProtectionDomain.class} |
| ) |
| @AndroidOnly("define methods re not supported on Android. " + |
| "UnsupportedOperationException should be thrown.") |
| public void test_defineClassLjava_lang_StringLByteBufferLProtectionDomain() { |
| |
| try { |
| try { |
| Class<?> a = new Ldr().define(Ldr.TEST_CASE_DEFINE_3); |
| //assertEquals("org.apache.harmony.luni.tests.java.lang.A", a.getName()); |
| //assertEquals(getClass().getProtectionDomain(), a.getProtectionDomain()); |
| fail("UnsupportedOperationException was not thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| new Ldr().define(1000, Ldr.TEST_CASE_DEFINE_3); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| fail("UnsupportedOperationException should be thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| } catch(Exception e) { |
| fail("Unexpected exception was thrown: " + e.toString()); |
| } |
| } |
| |
| /** |
| * Tests that Classloader.defineClass() assigns appropriate |
| * default domains to the defined classes. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "This method is not supported. " + |
| "UnsupportedOperationException should be thrown.", |
| method = "defineClass", |
| args = {java.lang.String.class, byte[].class, int.class, int.class} |
| ) |
| @AndroidOnly("define methods re not supported on Android. " + |
| "UnsupportedOperationException should be thrown.") |
| public void test_defineClass_defaultDomain() throws Exception { |
| try { |
| Class<?> a = new Ldr().define(Ldr.TEST_CASE_DEFINE_0); |
| fail("UnsupportedOperationException was not thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| |
| try { |
| new Ldr().define(1000, Ldr.TEST_CASE_DEFINE_0); |
| fail("IndexOutOfBoundsException is not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| fail("UnsupportedOperationException should be thrown."); |
| } catch(UnsupportedOperationException uoe) { |
| //expected |
| } |
| } |
| |
| static class SyncTestClassLoader extends ClassLoader { |
| Object lock; |
| volatile int numFindClassCalled; |
| |
| SyncTestClassLoader(Object o) { |
| this.lock = o; |
| numFindClassCalled = 0; |
| } |
| |
| /* |
| * Byte array of bytecode equivalent to the following source code: |
| * public class TestClass { |
| * } |
| */ |
| private byte[] classData = new byte[] { |
| -54, -2, -70, -66, 0, 0, 0, 49, 0, 13, |
| 10, 0, 3, 0, 10, 7, 0, 11, 7, 0, |
| 12, 1, 0, 6, 60, 105, 110, 105, 116, 62, |
| 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, |
| 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, |
| 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, |
| 101, 1, 0, 10, 83, 111, 117, 114, 99, 101, |
| 70, 105, 108, 101, 1, 0, 14, 84, 101, 115, |
| 116, 67, 108, 97, 115, 115, 46, 106, 97, 118, |
| 97, 12, 0, 4, 0, 5, 1, 0, 9, 84, |
| 101, 115, 116, 67, 108, 97, 115, 115, 1, 0, |
| 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, |
| 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, |
| 2, 0, 3, 0, 0, 0, 0, 0, 1, 0, |
| 1, 0, 4, 0, 5, 0, 1, 0, 6, 0, |
| 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, |
| 5, 42, -73, 0, 1, -79, 0, 0, 0, 1, |
| 0, 7, 0, 0, 0, 6, 0, 1, 0, 0, |
| 0, 1, 0, 1, 0, 8, 0, 0, 0, 2, |
| 0, 9 }; |
| |
| protected Class findClass(String name) throws ClassNotFoundException { |
| try { |
| while (flag != 2) { |
| synchronized (lock) { |
| lock.wait(); |
| } |
| } |
| } catch (InterruptedException ie) {} |
| |
| if (name.equals("TestClass")) { |
| numFindClassCalled++; |
| return defineClass(null, classData, 0, classData.length); |
| } else { |
| throw new ClassNotFoundException("Class " + name + " not found."); |
| } |
| } |
| } |
| |
| static class SyncLoadTestThread extends Thread { |
| volatile boolean started; |
| ClassLoader cl; |
| Class cls; |
| |
| SyncLoadTestThread(ClassLoader cl) { |
| this.cl = cl; |
| } |
| |
| public void run() { |
| try { |
| started = true; |
| cls = Class.forName("TestClass", false, cl); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| } |
| |
| /** |
| * Regression test for HARMONY-1939: |
| * 2 threads simultaneously run Class.forName() method for the same classname |
| * and the same classloader. It is expected that both threads succeed but |
| * class must be defined just once. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Regression test.", |
| method = "loadClass", |
| args = {java.lang.String.class} |
| ) |
| @BrokenTest("Defining classes not supported, unfortunately the test appears" |
| + " to succeed, which is not true, so marking it broken.") |
| public void test_loadClass_concurrentLoad() throws Exception |
| { |
| Object lock = new Object(); |
| SyncTestClassLoader cl = new SyncTestClassLoader(lock); |
| SyncLoadTestThread tt1 = new SyncLoadTestThread(cl); |
| SyncLoadTestThread tt2 = new SyncLoadTestThread(cl); |
| flag = 1; |
| tt1.start(); |
| tt2.start(); |
| |
| while (!tt1.started && !tt2.started) { |
| Thread.sleep(100); |
| } |
| |
| flag = 2; |
| synchronized (lock) { |
| lock.notifyAll(); |
| } |
| tt1.join(); |
| tt2.join(); |
| |
| assertSame("Bad or redefined class", tt1.cls, tt2.cls); |
| assertEquals("Both threads tried to define class", 1, cl.numFindClassCalled); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "loadClass", |
| args = {java.lang.String.class} |
| ) |
| public void test_loadClassLjava_lang_String() { |
| |
| String [] classNames = {"org.apache.harmony.luni.tests.java.lang.TestClass1", |
| "org.apache.harmony.luni.tests.java.lang.TestClass3", |
| "org.apache.harmony.luni.tests.java.lang.A"}; |
| |
| ClassLoader cl = getClass().getClassLoader(); |
| for(String str:classNames) { |
| try { |
| Class<?> clazz = cl.loadClass(str); |
| assertNotNull(clazz); |
| assertEquals(str, clazz.getName()); |
| if(str.endsWith("A")) |
| clazz.newInstance(); |
| if(str.endsWith("TestClass1")) { |
| try { |
| clazz.newInstance(); |
| fail("ExceptionInInitializerError was not thrown."); |
| } catch(ExceptionInInitializerError eiine) { |
| //expected |
| } |
| } |
| if(str.endsWith("TestClass3")) { |
| try { |
| clazz.newInstance(); |
| fail("IllegalAccessException was not thrown."); |
| } catch(IllegalAccessException ie) { |
| //expected |
| } |
| } |
| } catch (ClassNotFoundException e) { |
| fail("ClassNotFoundException was thrown." + e.getMessage()); |
| } catch (InstantiationException e) { |
| fail("InstantiationException was thrown."); |
| } catch (IllegalAccessException e) { |
| fail("IllegalAccessException was thrown."); |
| } |
| } |
| |
| try { |
| Class<?> clazz = cl.loadClass("org.apache.harmony.luni.tests.java.lang.TestClass4"); |
| fail("ClassNotFoundException was not thrown."); |
| } catch (ClassNotFoundException e) { |
| //expected |
| } |
| |
| try { |
| Class<?> clazz = cl.loadClass("org.apache.harmony.luni.tests.java.lang.TestClass5"); |
| fail("ClassNotFoundException was not thrown."); |
| } catch (ClassNotFoundException e) { |
| //expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "loadClass", |
| args = {java.lang.String.class, boolean.class} |
| ) |
| public void test_loadClassLjava_lang_StringLZ() throws |
| IllegalAccessException, InstantiationException, |
| ClassNotFoundException { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| String className = getClass().getPackage().getName() + ".A"; |
| |
| Class<?> clazz = pcl.loadClass(className, false); |
| assertEquals(className, clazz.getName()); |
| assertNotNull(clazz.newInstance()); |
| |
| clazz = pcl.loadClass(className, true); |
| assertEquals(className, clazz.getName()); |
| assertNotNull(clazz.newInstance()); |
| |
| try { |
| clazz = pcl.loadClass("UnknownClass", false); |
| assertEquals("TestClass", clazz.getName()); |
| fail("ClassNotFoundException was not thrown."); |
| } catch (ClassNotFoundException e) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests java.lang.ClassLoader#getResource(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getResource", |
| args = {java.lang.String.class} |
| ) |
| public void test_getResourceLjava_lang_String() { |
| // Test for method java.net.URL |
| // java.lang.ClassLoader.getResource(java.lang.String) |
| java.net.URL u = getClass().getClassLoader().getResource("hyts_Foo.c"); |
| assertNotNull("Unable to find resource", u); |
| java.io.InputStream is = null; |
| try { |
| is = u.openStream(); |
| assertNotNull("Resource returned is invalid", is); |
| is.close(); |
| } catch (java.io.IOException e) { |
| fail("IOException getting stream for resource : " + e.getMessage()); |
| } |
| |
| |
| |
| assertNull(getClass().getClassLoader() |
| .getResource("not.found.resource")); |
| } |
| |
| /** |
| * @tests java.lang.ClassLoader#getResourceAsStream(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getResourceAsStream", |
| args = {java.lang.String.class} |
| ) |
| public void test_getResourceAsStreamLjava_lang_String() { |
| // Test for method java.io.InputStream |
| // java.lang.ClassLoader.getResourceAsStream(java.lang.String) |
| // Need better test... |
| |
| java.io.InputStream is = null; |
| assertNotNull("Failed to find resource: HelloWorld.txt", |
| (is = getClass().getClassLoader() |
| .getResourceAsStream("HelloWorld.txt"))); |
| |
| byte [] array = new byte[13]; |
| try { |
| is.read(array); |
| } catch(IOException ioe) { |
| fail("IOException was not thrown."); |
| } finally { |
| try { |
| is.close(); |
| } catch(IOException ioe) {} |
| } |
| |
| assertEquals("Hello, World.", new String(array)); |
| |
| |
| try { |
| is.close(); |
| } catch (java.io.IOException e) { |
| fail("Exception during getResourceAsStream: " + e.toString()); |
| } |
| |
| assertNull(getClass().getClassLoader(). |
| getResourceAsStream("unknownResource.txt")); |
| } |
| |
| /** |
| * @tests java.lang.ClassLoader#getSystemClassLoader() |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "", |
| method = "getSystemClassLoader", |
| args = {} |
| ) |
| public void test_getSystemClassLoader() { |
| // Test for method java.lang.ClassLoader |
| // java.lang.ClassLoader.getSystemClassLoader() |
| ClassLoader cl = ClassLoader.getSystemClassLoader(); |
| |
| java.io.InputStream is = cl.getResourceAsStream("classes.dex"); |
| assertNotNull("Failed to find resource from system classpath", is); |
| try { |
| is.close(); |
| } catch (java.io.IOException e) { |
| } |
| |
| SecurityManager sm = new SecurityManager() { |
| public void checkPermission(Permission perm) { |
| if(perm.getName().equals("getClassLoader")) { |
| throw new SecurityException(); |
| } |
| } |
| }; |
| |
| SecurityManager oldManager = System.getSecurityManager(); |
| System.setSecurityManager(sm); |
| try { |
| ClassLoader.getSystemClassLoader(); |
| } catch(SecurityException se) { |
| //expected |
| } finally { |
| System.setSecurityManager(oldManager); |
| } |
| /* |
| * // java.lang.Error is not thrown on RI, but it's specified. |
| * |
| * String keyProp = "java.system.class.loader"; |
| * String oldProp = System.getProperty(keyProp); |
| * System.setProperty(keyProp, "java.test.UnknownClassLoader"); |
| * boolean isFailed = false; |
| * try { |
| * ClassLoader.getSystemClassLoader(); |
| * isFailed = true; |
| * } catch(java.lang.Error e) { |
| * //expected |
| * } finally { |
| * if(oldProp == null) { |
| * System.clearProperty(keyProp); |
| * } else { |
| * System.setProperty(keyProp, oldProp); |
| * } |
| * } |
| * assertFalse("java.lang.Error was not thrown.", isFailed); |
| */ |
| } |
| |
| /** |
| * @tests java.lang.ClassLoader#getSystemResource(java.lang.String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSystemResource", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("The RI doesn't have a classes.dex as resource in the " |
| + "core-tests.jar. Also on Android this file is the only one " |
| + "that is sure to exist.") |
| public void test_getSystemResourceLjava_lang_String() throws IOException { |
| // java.lang.ClassLoader.getSystemResource(java.lang.String) |
| // Need better test... |
| |
| |
| //String classResource = getClass().getPackage().getName().replace(".", "/") + "/" + |
| // getClass().getSimpleName() + ".class"; |
| //assertNotNull("Failed to find resource: " + classResource, |
| // ClassLoader.getSystemResource(classResource)); |
| |
| URL url = getClass().getClassLoader().getSystemResource("classes.dex"); |
| assertNotNull("Failed to find resource: classes.dex", url); |
| java.io.InputStream is = url.openStream(); |
| |
| assertTrue("System resource not found", is.available() > 0); |
| assertNull("Doesn't return null for unknown resource.", |
| getClass().getClassLoader().getSystemResource("NotFound")); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSystemResourceAsStream", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("The RI doesn't have a classes.dex as resource in the " |
| + "core-tests.jar. Also on Android this file is the only one " |
| + "that is sure to exist.") |
| public void test_getSystemResourceAsStreamLjava_lang_String() |
| throws IOException { |
| |
| //String classResource = getClass().getPackage().getName().replace(".", "/") + "/" + |
| // getClass().getSimpleName() + ".class"; |
| //assertNotNull("Failed to find resource: " + classResource, |
| // ClassLoader.getSystemResourceAsStream(classResource)); |
| |
| java.io.InputStream is = getClass().getClassLoader() |
| .getSystemResourceAsStream("classes.dex"); |
| assertNotNull("Failed to find resource: classes.dex", is); |
| |
| assertTrue("System resource not found", is.available() > 0); |
| |
| assertNull(ClassLoader.getSystemResourceAsStream("NotFoundResource")); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSystemResources", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("The RI doesn't have a classes.dex as resource in the " |
| + "core-tests.jar. Also on Android this file is the only one " |
| + "that is sure to exist.") |
| public void test_getSystemResources() { |
| |
| String textResource = "classes.dex"; |
| |
| try { |
| Enumeration<URL> urls = ClassLoader.getSystemResources(textResource); |
| assertNotNull(urls); |
| assertTrue(urls.nextElement().getPath().endsWith(textResource)); |
| while (urls.hasMoreElements()) { |
| assertNotNull(urls.nextElement()); |
| } |
| try { |
| urls.nextElement(); |
| fail("NoSuchElementException was not thrown."); |
| } catch(NoSuchElementException nse) { |
| //expected |
| } |
| } catch(IOException ioe) { |
| fail("IOException was thrown."); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getPackage", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("PackageClassLoader.getPackage returns null.") |
| public void test_getPackageLjava_lang_String() { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| |
| String [] packageProperties = { "test.package", "title", "1.0", |
| "Vendor", "Title", "1.1", "implementation vendor"}; |
| |
| URL url = null; |
| try { |
| url = new URL("file:"); |
| } catch (MalformedURLException e) { |
| fail("MalformedURLException was thrown."); |
| } |
| pcl.definePackage(packageProperties[0], |
| packageProperties[1], |
| packageProperties[2], |
| packageProperties[3], |
| packageProperties[4], |
| packageProperties[5], |
| packageProperties[6], |
| url); |
| |
| assertNotNull(pcl.getPackage(packageProperties[0])); |
| |
| assertEquals("should define current package", getClass().getPackage(), |
| pcl.getPackage(getClass().getPackage().getName())); |
| |
| assertNull(pcl.getPackage("not.found.package")); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getPackages", |
| args = {} |
| ) |
| @KnownFailure("The package canot be found. Seems like the cache is not " + |
| "shared between the class loaders. But this test seems to " + |
| "expect exactly that. this tests works on the RI.") |
| public void test_getPackages() { |
| |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| |
| String [] packageProperties = { "test.package", "title", "1.0", |
| "Vendor", "Title", "1.1", "implementation vendor"}; |
| |
| URL url = null; |
| try { |
| url = new URL("file:"); |
| } catch (MalformedURLException e) { |
| fail("MalformedURLException was thrown."); |
| } |
| pcl.definePackage(packageProperties[0], |
| packageProperties[1], |
| packageProperties[2], |
| packageProperties[3], |
| packageProperties[4], |
| packageProperties[5], |
| packageProperties[6], |
| url); |
| |
| Package [] packages = pcl.getPackages(); |
| assertTrue(packages.length != 0); |
| |
| pcl = new PackageClassLoader(getClass().getClassLoader()); |
| packages = pcl.getPackages(); |
| assertNotNull(packages); |
| |
| boolean isThisFound = false; |
| for(Package p:packages) { |
| if(p.equals(getClass().getPackage())) { |
| isThisFound = true; |
| } |
| } |
| assertTrue(isThisFound); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getParent", |
| args = {} |
| ) |
| public void test_getParent() { |
| PublicClassLoader pcl = new PublicClassLoader(); |
| assertNotNull(pcl.getParent()); |
| ClassLoader cl = getClass().getClassLoader().getParent(); |
| assertNotNull(cl); |
| |
| SecurityManager sm = new SecurityManager() { |
| |
| final String perName = "getClassLoader"; |
| |
| public void checkPermission(Permission perm) { |
| if (perm.getName().equals(perName)) { |
| throw new SecurityException(); |
| } |
| } |
| }; |
| |
| SecurityManager oldSm = System.getSecurityManager(); |
| System.setSecurityManager(sm); |
| try { |
| getClass().getClassLoader().getParent(); |
| fail("Should throw SecurityException"); |
| } catch (SecurityException e) { |
| // expected |
| } finally { |
| System.setSecurityManager(oldSm); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getResources", |
| args = {java.lang.String.class} |
| ) |
| public void test_getResourcesLjava_lang_String() { |
| Enumeration<java.net.URL> urls = null; |
| FileInputStream fis = null; |
| try { |
| urls = getClass().getClassLoader().getResources("HelloWorld.txt"); |
| URL url = urls.nextElement(); |
| fis = new FileInputStream(url.getFile()); |
| byte [] array = new byte[13]; |
| fis.read(array); |
| assertEquals("Hello, World.", new String(array)); |
| } catch (IOException e) { |
| |
| } finally { |
| try { |
| fis.close(); |
| } catch(Exception e) {} |
| } |
| |
| assertNull(getClass().getClassLoader() |
| .getResource("not.found.resource")); |
| |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "definePackage", |
| args = {java.lang.String.class, java.lang.String.class, |
| java.lang.String.class, java.lang.String.class, |
| java.lang.String.class, java.lang.String.class, |
| java.lang.String.class, java.net.URL.class } |
| ) |
| public void test_definePackage() { |
| |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| |
| String [] packageProperties = { "test.package", "title", "1.0", |
| "Vendor", "Title", "1.1", "implementation vendor"}; |
| |
| URL url = null; |
| try { |
| url = new URL("file:"); |
| } catch (MalformedURLException e) { |
| fail("MalformedURLException was thrown."); |
| } |
| pcl.definePackage(packageProperties[0], |
| packageProperties[1], |
| packageProperties[2], |
| packageProperties[3], |
| packageProperties[4], |
| packageProperties[5], |
| packageProperties[6], |
| url); |
| |
| Package pack = pcl.getPackage(packageProperties[0]); |
| assertEquals(packageProperties[1], pack.getSpecificationTitle()); |
| assertEquals(packageProperties[2], pack.getSpecificationVersion()); |
| assertEquals(packageProperties[3], pack.getSpecificationVendor()); |
| assertEquals(packageProperties[4], pack.getImplementationTitle()); |
| assertEquals(packageProperties[5], pack.getImplementationVersion()); |
| assertEquals(packageProperties[6], pack.getImplementationVendor()); |
| assertTrue(pack.isSealed(url)); |
| assertTrue(pack.isSealed()); |
| |
| try { |
| pcl.definePackage(packageProperties[0], |
| packageProperties[1], |
| packageProperties[2], |
| packageProperties[3], |
| packageProperties[4], |
| packageProperties[5], |
| packageProperties[6], |
| null); |
| fail("IllegalArgumentException was not thrown."); |
| } catch(IllegalArgumentException iae) { |
| //expected |
| } |
| |
| pcl.definePackage("test.package.test", null, null, null, null, |
| null, null, null); |
| pack = pcl.getPackage("test.package.test"); |
| assertNull(pack.getSpecificationTitle()); |
| assertNull(pack.getSpecificationVersion()); |
| assertNull(pack.getSpecificationVendor()); |
| assertNull(pack.getImplementationTitle()); |
| assertNull(pack.getImplementationVersion()); |
| assertNull(pack.getImplementationVendor()); |
| assertFalse(pack.isSealed()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findClass", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("findClass method throws ClassNotFoundException exception.") |
| public void test_findClass(){ |
| |
| try { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| pcl.findClass(getClass().getPackage().getName() + ".A"); |
| fail("ClassNotFoundException was not thrown."); |
| } catch(ClassNotFoundException cnfe) { |
| //expected |
| } |
| |
| try { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| pcl.findClass("TestClass"); |
| fail("ClassNotFoundException was not thrown."); |
| } catch(ClassNotFoundException cnfe) { |
| //expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findLibrary", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("findLibrary method is not supported, it returns null.") |
| public void test_findLibrary() { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| assertNull(pcl.findLibrary("libjvm.so")); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findResource", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("findResource method is not supported, it returns null.") |
| public void test_findResourceLjava_lang_String() { |
| assertNull(new PackageClassLoader( |
| getClass().getClassLoader()).findResource("hyts_Foo.c")); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findResources", |
| args = {java.lang.String.class} |
| ) |
| @AndroidOnly("findResources method is not supported, it returns " + |
| "empty Enumeration.") |
| public void test_findResourcesLjava_lang_String() throws IOException { |
| assertFalse(new PackageClassLoader( |
| getClass().getClassLoader()).findResources("hyts_Foo.c"). |
| hasMoreElements()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findSystemClass", |
| args = {java.lang.String.class} |
| ) |
| public void test_findSystemClass() { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| |
| Class [] classes = { String.class, Integer.class, Object.class, |
| Object[].class }; |
| |
| for(Class clazz:classes) { |
| try { |
| String className = clazz.getName(); |
| assertEquals(clazz, pcl.findSystemClazz(className)); |
| } catch(ClassNotFoundException cnfe) { |
| fail("ClassNotFoundException was thrown: " + cnfe.getMessage()); |
| } |
| } |
| try { |
| pcl.findSystemClazz("unknownClass"); |
| fail("ClassNotFoundException was not thrown."); |
| } catch(ClassNotFoundException cnfe) { |
| //expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "findLoadedClass", |
| args = {java.lang.String.class } |
| ) |
| public void test_findLoadedClass() { |
| PackageClassLoader pcl = new PackageClassLoader( |
| getClass().getClassLoader()); |
| |
| Class [] classes = { A.class, PublicTestClass.class, |
| TestAnnotation.class, TestClass1.class }; |
| |
| for(Class clazz:classes) { |
| String className = clazz.getName(); |
| assertNull(pcl.findLoadedClazz(className)); |
| } |
| |
| assertNull(pcl.findLoadedClazz("unknownClass")); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "setClassAssertionStatus is not supported.", |
| method = "setClassAssertionStatus", |
| args = {java.lang.String.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "setDefaultAssertionStatus is not supported.", |
| method = "setDefaultAssertionStatus", |
| args = {boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "setPackageAssertionStatus is not supported.", |
| method = "setPackageAssertionStatus", |
| args = {java.lang.String.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "resolveClass is not supported.", |
| method = "resolveClass", |
| args = {java.lang.Class.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "setSigners is not supported.", |
| method = "setSigners", |
| args = {java.lang.Class.class, java.lang.Object[].class} |
| ) |
| }) |
| public void test_notSupported() { |
| getClass().getClassLoader().setClassAssertionStatus(getName(), true); |
| getClass().getClassLoader().setDefaultAssertionStatus(true); |
| getClass().getClassLoader().setPackageAssertionStatus( |
| getClass().getPackage().getName(), true); |
| } |
| } |
| |
| class DynamicPolicy extends Policy { |
| |
| public PermissionCollection pc; |
| |
| @Override |
| public PermissionCollection getPermissions(ProtectionDomain pd) { |
| return pc; |
| } |
| |
| @Override |
| public PermissionCollection getPermissions(CodeSource codesource) { |
| return pc; |
| } |
| |
| @Override |
| public void refresh() { |
| } |
| } |
| |
| class A { |
| } |
| |
| class Ldr extends ClassLoader { |
| |
| /* |
| * These bytes are the content of the file |
| * /org/apache/harmony/luni/tests/java/lang/A.class |
| */ |
| byte[] classBytes = new byte[] { -54, -2, -70, -66, 0, 0, 0, 49, 0, 16, 7, |
| 0, 2, 1, 0, 41, 111, 114, 103, 47, 97, 112, 97, 99, 104, 101, 47, |
| 104, 97, 114, 109, 111, 110, 121, 47, 108, 117, 110, 105, 47, 116, |
| 101, 115, 116, 115, 47, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, |
| 65, 7, 0, 4, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, |
| 79, 98, 106, 101, 99, 116, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, |
| 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 10, 0, 3, 0, 9, 12, 0, |
| 5, 0, 6, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, |
| 84, 97, 98, 108, 101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97, 114, |
| 105, 97, 98, 108, 101, 84, 97, 98, 108, 101, 1, 0, 4, 116, 104, 105, |
| 115, 1, 0, 43, 76, 111, 114, 103, 47, 97, 112, 97, 99, 104, 101, 47, |
| 104, 97, 114, 109, 111, 110, 121, 47, 108, 117, 110, 105, 47, 116, |
| 101, 115, 116, 115, 47, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, |
| 65, 59, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, |
| 0, 20, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 84, 101, |
| 115, 116, 46, 106, 97, 118, 97, 0, 32, 0, 1, 0, 3, 0, 0, 0, 0, 0, 1, |
| 0, 0, 0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 47, 0, 1, 0, 1, 0, 0, 0, 5, |
| 42, -73, 0, 8, -79, 0, 0, 0, 2, 0, 10, 0, 0, 0, 6, 0, 1, 0, 0, 4, |
| -128, 0, 11, 0, 0, 0, 12, 0, 1, 0, 0, 0, 5, 0, 12, 0, 13, 0, 0, 0, |
| 1, 0, 14, 0, 0, 0, 2, 0, 15 }; |
| |
| public static final int TEST_CASE_DEFINE_0 = 0; |
| public static final int TEST_CASE_DEFINE_1 = 1; |
| public static final int TEST_CASE_DEFINE_2 = 2; |
| public static final int TEST_CASE_DEFINE_3 = 3; |
| |
| @SuppressWarnings("deprecation") |
| public Class<?> define(int len, int testCase) throws Exception { |
| |
| if(len < 0) len = classBytes.length; |
| Class<?> clazz = null; |
| String className = "org.apache.harmony.luni.tests.java.lang.A"; |
| switch(testCase) { |
| case TEST_CASE_DEFINE_0: |
| clazz = defineClass(className, classBytes, 0, len); |
| break; |
| case TEST_CASE_DEFINE_1: |
| clazz = defineClass(classBytes, 0, len); |
| break; |
| case TEST_CASE_DEFINE_2: |
| clazz = defineClass(className, classBytes, 0, len, |
| getClass().getProtectionDomain()); |
| break; |
| case TEST_CASE_DEFINE_3: |
| ByteBuffer bb = ByteBuffer.wrap(classBytes); |
| clazz = defineClass(className, |
| bb, getClass().getProtectionDomain()); |
| break; |
| } |
| return clazz; |
| } |
| |
| public Class<?> define(int testCase) throws Exception { |
| return define(-1, testCase); |
| } |
| |
| } |
| |
| class PackageClassLoader extends ClassLoader { |
| public PackageClassLoader() { |
| super(); |
| } |
| |
| public PackageClassLoader(ClassLoader parent) { |
| super(parent); |
| } |
| |
| public Package definePackage(String name, |
| String specTitle, |
| String specVersion, |
| String specVendor, |
| String implTitle, |
| String implVersion, |
| String implVendor, |
| URL sealBase) |
| throws IllegalArgumentException { |
| return super.definePackage(name, specTitle, specVersion, |
| specVendor, implTitle, implVersion, implVendor, sealBase); |
| } |
| |
| public Package getPackage(String name) { |
| return super.getPackage(name); |
| } |
| |
| public Package[] getPackages() { |
| return super.getPackages(); |
| } |
| |
| public Class<?> findClass(String name) |
| throws ClassNotFoundException { |
| return super.findClass(name); |
| } |
| |
| public String findLibrary(String libname) { |
| return super.findLibrary(libname); |
| } |
| |
| public Class<?> loadClass(String name, boolean resolve) |
| throws ClassNotFoundException { |
| return super.loadClass(name, resolve); |
| } |
| |
| public URL findResource(String name) { |
| return super.findResource(name); |
| } |
| |
| public Enumeration<URL> findResources(String resName) |
| throws IOException { |
| return super.findResources(resName); |
| } |
| |
| public Class<?> findSystemClazz(String name) throws ClassNotFoundException { |
| return super.findSystemClass(name); |
| } |
| |
| public Class<?> findLoadedClazz(String name) { |
| return super.findLoadedClass(name); |
| } |
| } |
