0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017:
0018: /**
0019: * @author Serguei S.Zapreyev
0020: * @version $Revision$
0021: */package java.lang;
0022:
0023: import java.io.File;
0024: import java.io.FileOutputStream;
0025: import java.io.IOException;
0026: import java.lang.reflect.Method;
0027: import java.net.URL;
0028:
0029: import org.apache.harmony.test.TestResources;
0030:
0031: import junit.framework.TestCase;
0032:
0033: /*
0034: * Created on 02.04.2006
0035: *
0036: * This ClassLoaderTest class is used to test the Core API
0037: * java.lang.ClassLoader class
0038: *
0039: */
0040:
0041: @SuppressWarnings(value={"all"})
0042: public class ClassLoaderTest extends TestCase {
0043:
0044: static String vendor = System.getProperty("java.vm.vendor");
0045:
0046: class TestClassLoader extends ClassLoader {
0047: // Use only for top level classes
0048:
0049: public Class<?> findClass(String name) {
0050: String nm = name.substring(1, name.length());
0051: byte[] b = loadClassData(nm);
0052: return defineClass(nm, b, 0, b.length);
0053: }
0054:
0055: private byte[] loadClassData(String name) {
0056: //return new byte[0];
0057: //System.out.println("loadClassData: "+ name);
0058: String nm = name.replace('.', '/');
0059: java.io.InputStream is = this .getClass()
0060: .getResourceAsStream("/" + nm + ".class");
0061: //System.out.println("loadClassData: "+ nm);
0062: try {
0063: int len = is.available();
0064: byte ab[] = new byte[len];
0065: is.read(ab);
0066: return ab;
0067: } catch (java.io.IOException _) {
0068: }
0069: return null;
0070: }
0071:
0072: public TestClassLoader() {
0073: super ();
0074: }
0075:
0076: public TestClassLoader(ClassLoader cl) {
0077: super (cl);
0078: }
0079: }
0080:
0081: /**
0082: *
0083: */
0084: public void test_ClassLoader_V() {
0085: assertTrue("Error1",
0086: new TestClassLoader().getParent() == TestClassLoader
0087: .getSystemClassLoader());
0088: }
0089:
0090: /**
0091: *
0092: */
0093: public void test_ClassLoader_Cla() {
0094: TestClassLoader tcl = new TestClassLoader();
0095: assertTrue("Error1", new TestClassLoader((ClassLoader) tcl)
0096: .getParent() == tcl);
0097: }
0098:
0099: /**
0100: *
0101: */
0102: public void test_clearAssertionStatus_V() {
0103: TestClassLoader tcl = new TestClassLoader();
0104: ((ClassLoader) tcl).clearAssertionStatus();
0105:
0106: ClassLoader cl = Class.class.getClassLoader();
0107: if (cl == null)
0108: cl = ClassLoader.getSystemClassLoader();
0109: cl.clearAssertionStatus();
0110: try {
0111: Class c = cl
0112: .loadClass("javax.xml.transform.stream.StreamResult");
0113: try {
0114: c.newInstance(); // to be initialized
0115: } catch (Exception _) {
0116: //System.out.println("(test_clearAssertionStatus_V)Exception
0117: // 1");
0118: }
0119: assertTrue("Error1:", c.desiredAssertionStatus() == c
0120: .desiredAssertionStatus()); // "this method is not
0121: // guaranteed to return the
0122: // actual assertion status"
0123: } catch (ClassNotFoundException _) {
0124: System.out.println("ClassNotFoundException 1");
0125: }
0126: }
0127:
0128: /**
0129: *
0130: */
0131: //Commented because of the drlvm issue
0132: // public void te_st_defineClass_BArr_I_I() {
0133: public void test_defineClass_BArr_I_I() {
0134: class LCL extends ClassLoader {
0135: // only for special case
0136:
0137: public Class findClass(String name) {
0138: String nm = name.substring(1, name.length());
0139: byte[] b = loadClassData(nm);
0140: if (nm.endsWith("SAXTransformerFactory")) {
0141: return defineClass(b, 0, b.length); // ALL RIGHT
0142: } else if (nm.endsWith("SAXSource")) {
0143: return defineClass(b, 10, b.length - 20); // ClassFormatError
0144: } else if (nm.endsWith("SAXResult")) {
0145: return defineClass(b, 0, b.length + 20); // IndexOutOfBoundsException
0146: }
0147: return null;
0148: }
0149:
0150: private byte[] loadClassData(String name) {
0151: //System.out.println("loadClassData: "+ name);
0152: String nm = name.replace('.', '/');
0153: java.io.InputStream is = this .getClass()
0154: .getResourceAsStream("/" + nm + ".class");
0155: //System.out.println("loadClassData: "+ nm);
0156: try {
0157: int len = is.available();
0158: byte ab[] = new byte[len];
0159: is.read(ab);
0160: return ab;
0161: } catch (java.io.IOException _) {
0162: }
0163: return null;
0164: }
0165:
0166: public LCL() {
0167: super ();
0168: }
0169:
0170: public LCL(ClassLoader cl) {
0171: super (cl);
0172: }
0173: }
0174:
0175: LCL tcl = new LCL();
0176:
0177: // TEST CASE #1:
0178: try {
0179: Class c = tcl
0180: .loadClass("#javax.xml.transform.sax.SAXTransformerFactory");
0181: assertTrue("Error1", c != null);
0182: } catch (ClassNotFoundException _) {
0183: }
0184:
0185: // TEST CASE #2:
0186: try {
0187: Class c = tcl
0188: .loadClass("#javax.xml.transform.sax.SAXSource");
0189: fail("Error2: ");
0190: } catch (ClassFormatError _) {
0191: } catch (ClassNotFoundException e) {
0192: fail("Error3: " + e.toString());
0193: }
0194:
0195: // TEST CASE #3:
0196: try {
0197: Class c = tcl
0198: .loadClass("#javax.xml.transform.sax.SAXResult");
0199: fail("Error4: ");
0200: } catch (IndexOutOfBoundsException _) {
0201: } catch (ClassNotFoundException e) {
0202: fail("Error5: " + e.toString());
0203: }
0204: }
0205:
0206: /**
0207: *
0208: */
0209: public void test_defineClass_Str_BArr_I_I() {
0210: class LCL extends ClassLoader {
0211: // only for special case
0212:
0213: public Class<?> findClass(String name) {
0214: String nm = name.substring(1, name.length());
0215: byte[] b = loadClassData(nm);
0216: if (nm.endsWith("SAXTransformerFactory")) {
0217: return defineClass(nm, b, 0, b.length); // ALL RIGHT
0218: } else if (nm.endsWith("SAXSource")) {
0219: return defineClass(nm, b, 10, b.length - 20); // ClassFormatError
0220: } else if (nm.endsWith("SAXResult")) {
0221: return defineClass(nm, b, 0, b.length + 20); // IndexOutOfBoundsException
0222: } else if (nm.endsWith("DOMResult")) {
0223: return defineClass(nm + "XXX", b, 0, b.length); // NoClassDefFoundError
0224: } else if (nm.endsWith("Calendar")) {
0225: return defineClass(nm, b, 0, b.length); // SecurityException
0226: }
0227: return null;
0228: }
0229:
0230: private byte[] loadClassData(String name) {
0231: String nm = name.replace('.', '/');
0232: java.io.InputStream is = this .getClass()
0233: .getResourceAsStream("/" + nm + ".class");
0234: try {
0235: int len = is.available();
0236: byte ab[] = new byte[len];
0237: is.read(ab);
0238: return ab;
0239: } catch (java.io.IOException _) {
0240: }
0241: return null;
0242: }
0243:
0244: public LCL() {
0245: super ();
0246: }
0247: }
0248:
0249: LCL tcl = new LCL();
0250:
0251: // TEST CASE #1:
0252: try {
0253: Class c = tcl
0254: .loadClass("#javax.xml.transform.sax.SAXTransformerFactory");
0255: assertTrue("Error1", c != null);
0256: } catch (ClassNotFoundException _) {
0257: }
0258:
0259: // TEST CASE #2:
0260: try {
0261: tcl.loadClass("#javax.xml.transform.sax.SAXSource");
0262: fail("Error2: ");
0263: } catch (ClassFormatError _) {
0264: } catch (ClassNotFoundException e) {
0265: fail("Error3: " + e.toString());
0266: }
0267:
0268: // TEST CASE #3:
0269: try {
0270: tcl.loadClass("#javax.xml.transform.sax.SAXResult");
0271: fail("Error4: ");
0272: } catch (IndexOutOfBoundsException _) {
0273: } catch (ClassNotFoundException e) {
0274: fail("Error5: " + e.toString());
0275: }
0276:
0277: // TEST CASE #4:
0278: try {
0279: tcl.loadClass("#javax.xml.transform.dom.DOMResult");
0280: fail("Error6: ");
0281: } catch (NoClassDefFoundError _) {
0282: } catch (ClassNotFoundException e) {
0283: fail("Error7: " + e.toString());
0284: }
0285:
0286: // TEST CASE #5:
0287: try {
0288: tcl.loadClass("#java.util.Calendar");
0289: fail("Error8: ");
0290: } catch (SecurityException _) {
0291: } catch (ClassNotFoundException e) {
0292: fail("Error9: " + e.toString());
0293: }
0294: }
0295:
0296: /**
0297: *
0298: */
0299: public void test_defineClass_Str_BArr_I_I_Pro() {
0300: class LCL extends ClassLoader {
0301: // only for special case
0302:
0303: public Class<?> findClass(String name) {
0304: String nm = name.substring(1, name.length());
0305: //java.security.ProtectionDomain pd = new
0306: // java.security.ProtectionDomain(new CodeSource(new
0307: // java.net.URL(""), new java.security.cert.Certificate[]{} ),
0308: // new PermissionCollection());
0309: java.security.ProtectionDomain pd = Void.class
0310: .getProtectionDomain();
0311: byte[] b = loadClassData(nm);
0312: if (nm.endsWith("SAXTransformerFactory")) {
0313: return defineClass(nm, b, 0, b.length, pd); // ALL RIGHT
0314: } else if (nm.endsWith("SAXSource")) {
0315: return defineClass(nm, b, 10, b.length - 20, pd); // ClassFormatError
0316: } else if (nm.endsWith("SAXResult")) {
0317: return defineClass(nm, b, 0, b.length + 20, pd); // IndexOutOfBoundsException
0318: } else if (nm.endsWith("DOMResult")) {
0319: return defineClass(nm + "XXX", b, 0, b.length, pd); // NoClassDefFoundError
0320: } else if (nm.endsWith("Calendar")) {
0321: return defineClass(nm, b, 0, b.length, pd); // SecurityException
0322: } else if (nm.endsWith("TimeZone")) {
0323: return defineClass(nm, b, 0, b.length,
0324: (java.security.ProtectionDomain) null); // SecurityException
0325: }
0326: return null;
0327: }
0328:
0329: private byte[] loadClassData(String name) {
0330: String nm = name.replace('.', '/');
0331: java.io.InputStream is = this .getClass()
0332: .getResourceAsStream("/" + nm + ".class");
0333: try {
0334: int len = is.available();
0335: byte ab[] = new byte[len];
0336: is.read(ab);
0337: return ab;
0338: } catch (java.io.IOException _) {
0339: }
0340: return null;
0341: }
0342:
0343: public LCL() {
0344: super ();
0345: }
0346: }
0347:
0348: LCL tcl = new LCL();
0349:
0350: // TEST CASE #1:
0351: try {
0352: Class c = tcl
0353: .loadClass("#javax.xml.transform.sax.SAXTransformerFactory");
0354: assertTrue("Error1", c.getProtectionDomain().equals(
0355: Void.class.getProtectionDomain()));
0356: } catch (ClassNotFoundException _) {
0357: }
0358:
0359: // TEST CASE #2:
0360: try {
0361: tcl.loadClass("#javax.xml.transform.sax.SAXSource");
0362: fail("Error2: ");
0363: } catch (ClassFormatError _) {
0364: } catch (ClassNotFoundException e) {
0365: fail("Error3: " + e.toString());
0366: }
0367:
0368: // TEST CASE #3:
0369: try {
0370: tcl.loadClass("#javax.xml.transform.sax.SAXResult");
0371: fail("Error4: ");
0372: } catch (IndexOutOfBoundsException _) {
0373: } catch (ClassNotFoundException e) {
0374: fail("Error5: " + e.toString());
0375: }
0376:
0377: // TEST CASE #4:
0378: try {
0379: tcl.loadClass("#javax.xml.transform.dom.DOMResult");
0380: fail("Error6: ");
0381: } catch (NoClassDefFoundError _) {
0382: } catch (ClassNotFoundException e) {
0383: fail("Error7: " + e.toString());
0384: }
0385:
0386: // TEST CASE #5:
0387: try {
0388: tcl.loadClass("#java.util.Calendar");
0389: fail("Error8: ");
0390: } catch (SecurityException _) {
0391: } catch (ClassNotFoundException e) {
0392: fail("Error9: " + e.toString());
0393: }
0394:
0395: // TEST CASE #5:
0396: try {
0397: tcl.loadClass("#java.util.TimeZona");
0398: fail("Error10: ");
0399: } catch (NullPointerException _) {
0400: } catch (ClassNotFoundException e) {
0401: fail("Error11: " + e.toString());
0402: }
0403: }
0404:
0405: /**
0406: *
0407: */
0408: public void test_definePackage_Str_Str_Str_Str_Str_Str_Str_Str_URL() {
0409: class LCL extends ClassLoader {
0410: // only for special case
0411:
0412: public Class<?> findClass(String name) {
0413: String nm = name.substring(1, name.length());
0414: byte[] b = loadClassData(nm);
0415: if (nm.endsWith("AudioFileReader")
0416: || nm.endsWith("AudioFileWriter")) {
0417: return defineClass(b, 0, b.length); // ALL RIGHT
0418: }
0419: return null;
0420: }
0421:
0422: private byte[] loadClassData(String name) {
0423: String nm = name.replace('.', '/');
0424: java.io.InputStream is = this .getClass()
0425: .getResourceAsStream("/" + nm + ".class");
0426: try {
0427: int len = is.available();
0428: byte ab[] = new byte[len];
0429: is.read(ab);
0430: return ab;
0431: } catch (java.io.IOException _) {
0432: }
0433: return null;
0434: }
0435:
0436: public LCL() {
0437: super ();
0438: }
0439: }
0440:
0441: LCL tcl = new LCL();
0442:
0443: // TEST CASE #1:
0444: try {
0445: ClassLoader cl = Class.class.getClassLoader();
0446: if (cl == null)
0447: cl = ClassLoader.getSystemClassLoader();
0448: cl.definePackage("javax.swing.filechooser", "ZSSspecTitle",
0449: "ZSSspecVersion", "ZSSspecVendor", "ZSSimplTitle",
0450: "ZSSimplVersion", "ZSSimplVendor",
0451: new java.net.URL("http://intel.com/"));
0452: try {
0453: Class c1 = cl
0454: .loadClass("javax.swing.filechooser.FileFilter");
0455: Class c2 = cl
0456: .loadClass("javax.swing.filechooser.FileView");
0457: try {
0458: c1.newInstance(); // to be initialized
0459: c2.newInstance(); // to be initialized
0460: } catch (Exception _) {
0461: }
0462: //assertTrue("Error1", c1.getPackage().equals(c2.getPackage())
0463: // );
0464: assertTrue("Error1", cl.getPackage(
0465: "javax.swing.filechooser").getName().equals(
0466: "javax.swing.filechooser"));
0467: assertTrue("Error2 "
0468: + cl.getPackage("javax.swing.filechooser")
0469: .getSpecificationTitle(), cl
0470: .getPackage("javax.swing.filechooser")
0471: .getSpecificationTitle().equals("ZSSspecTitle"));
0472: assertTrue("Error3", cl.getPackage(
0473: "javax.swing.filechooser")
0474: .getSpecificationVersion().equals(
0475: "ZSSspecVersion"));
0476: assertTrue("Error4", cl.getPackage(
0477: "javax.swing.filechooser")
0478: .getSpecificationVendor().equals(
0479: "ZSSspecVendor"));
0480: assertTrue("Error5", cl.getPackage(
0481: "javax.swing.filechooser")
0482: .getImplementationTitle()
0483: .equals("ZSSimplTitle"));
0484: assertTrue("Error6", cl.getPackage(
0485: "javax.swing.filechooser")
0486: .getImplementationVersion().equals(
0487: "ZSSimplVersion"));
0488: assertTrue("Error7", cl.getPackage(
0489: "javax.swing.filechooser")
0490: .getImplementationVendor().equals(
0491: "ZSSimplVendor"));
0492: } catch (ClassNotFoundException _) {
0493: System.out.println("ClassNotFoundException 1");
0494: }
0495:
0496: } catch (java.net.MalformedURLException _) {
0497: }
0498:
0499: // TEST CASE #2:
0500: try {
0501: tcl.definePackage("javax.swing.filechooser",
0502: "ZSSspecTitle", "ZSSspecVersion", "ZSSspecVendor",
0503: "ZSSimplTitle", "ZSSimplVersion", "ZSSimplVendor",
0504: new java.net.URL("http://intel.com/"));
0505: fail("Error8");
0506: } catch (java.lang.IllegalArgumentException _) {
0507: // CORRECT !
0508: } catch (java.net.MalformedURLException _) {
0509: fail("Error9");
0510: }
0511:
0512: // TEST CASE #3:
0513: try {
0514: tcl.definePackage("javax.swing.plaf.basic", "ZSSspecTitle",
0515: "ZSSspecVersion", "ZSSspecVendor", "ZSSimplTitle",
0516: "ZSSimplVersion", "ZSSimplVendor",
0517: new java.net.URL("http://intel.com/"));
0518:
0519: tcl.loadClass("#javax.swing.plaf.basic.BasicBorders");
0520: tcl.loadClass("#javax.swing.plaf.basic.BasicArrowButton");
0521: assertTrue("Error10", tcl.getPackage(
0522: "javax.swing.plaf.basic").getName().equals(
0523: "javax.swing.plaf.basic"));
0524: } catch (ClassNotFoundException _) {
0525: } catch (java.net.MalformedURLException _) {
0526: }
0527: }
0528:
0529: /**
0530: *
0531: */
0532: public void test_findClass_Str() {
0533: class LCL extends ClassLoader {
0534: // only for special case
0535:
0536: public Class<?> findClass(String name)
0537: throws ClassNotFoundException {
0538: return super .findClass(name);
0539: }
0540:
0541: public LCL() {
0542: super ();
0543: }
0544: }
0545:
0546: LCL tcl = new LCL();
0547:
0548: // TEST CASE #1:
0549: try {
0550: tcl.loadClass("#javax.swing.plaf.basic.BasicBorders");
0551: fail("Error1");
0552: } catch (ClassNotFoundException _) {
0553: } catch (Throwable _) {
0554: fail("Error2");
0555: }
0556:
0557: // TEST CASE #2:
0558: try {
0559: tcl.loadClass(null);
0560: fail("Error3");
0561: } catch (NullPointerException _) {
0562: } catch (Throwable _) {
0563: fail("Error4");
0564: }
0565:
0566: // TEST CASE #3:
0567: try {
0568: tcl.loadClass("java.lang.Object");
0569: } catch (ClassNotFoundException _) {
0570: } catch (Throwable e) {
0571: fail("Error6 " + e.toString());
0572: }
0573: }
0574:
0575: /**
0576: *
0577: */
0578: public void test_findLibrary_Str() {
0579: class LCL extends ClassLoader {
0580: // only for special case
0581:
0582: public Class<?> findClass(String name)
0583: throws ClassNotFoundException {
0584: return super .findClass(name);
0585: }
0586:
0587: public LCL() {
0588: super ();
0589: }
0590: }
0591:
0592: LCL tcl = new LCL();
0593:
0594: // TEST CASE #1:
0595: if (vendor.equals("Intel DRL")) {
0596: tcl.findLibrary(System.mapLibraryName("java"));
0597: }
0598:
0599: // TEST CASE #2:
0600: ClassLoader cl = Class.class.getClassLoader();
0601: if (cl == null)
0602: cl = ClassLoader.getSystemClassLoader();
0603: if (vendor.equals("Intel DRL")) {
0604: cl.findLibrary(System.mapLibraryName("lang"));
0605: }
0606:
0607: // TEST CASE #3:
0608: tcl.findLibrary(null);
0609: }
0610:
0611: /**
0612: *
0613: */
0614: public void test_findLoadedClass_Str() {
0615: class LCL extends ClassLoader {
0616: // only for special case
0617:
0618: public Class<?> findClass(String name) {
0619: String nm = name.substring(1, name.length());
0620: if (nm.endsWith("JPEGImageReadParamXXX")) {
0621: byte[] b = loadClassData("j"
0622: + (nm.replaceAll("JPEGImageReadParamXXX",
0623: "JPEGImageReadParam")));
0624: return defineClass(b, 0, b.length); // ALL RIGHT
0625: }
0626: byte[] b = loadClassData(nm);
0627: if (nm.endsWith("IIOImage")) {
0628: return defineClass(b, 0, b.length); // ALL RIGHT
0629: }
0630: if (nm.endsWith("TemplateSet")) {
0631: return defineClass(b, 0, b.length); // ALL RIGHT
0632: }
0633: return null;
0634: }
0635:
0636: private byte[] loadClassData(String name) {
0637: String nm = name.replace('.', '/');
0638: java.io.InputStream is = this .getClass()
0639: .getResourceAsStream("/" + nm + ".class");
0640: try {
0641: int len = is.available();
0642: byte ab[] = new byte[len];
0643: is.read(ab);
0644: return ab;
0645: } catch (java.io.IOException _) {
0646: }
0647: return null;
0648: }
0649:
0650: public LCL() {
0651: super ();
0652: }
0653: }
0654:
0655: LCL tcl = new LCL();
0656: ClassLoader cl = Class.class.getClassLoader();
0657: if (cl == null)
0658: cl = ClassLoader.getSystemClassLoader();
0659:
0660: // TEST CASE #1:
0661: try {
0662: tcl
0663: .loadClass("#org.apache.harmony.lang.generics.TemplateSet");
0664: assertTrue(
0665: "Error1",
0666: tcl
0667: .findLoadedClass(
0668: "org.apache.harmony.lang.generics.TemplateSet")
0669: .getName()
0670: .equals(
0671: "org.apache.harmony.lang.generics.TemplateSet"));
0672: } catch (Throwable e) {
0673: fail("Error2: " + e.toString());
0674: }
0675:
0676: // TEST CASE #2:
0677: try {
0678: assertTrue("Error3", cl.findLoadedClass(null) == null);
0679: } catch (Throwable e) {
0680: fail("Error4: " + e.toString());
0681: }
0682: try {
0683: assertTrue("Error33", tcl.findLoadedClass(null) == null);
0684: } catch (Throwable e) {
0685: fail("Error44: " + e.toString());
0686: }
0687:
0688: // TEST CASE #3:
0689: try {
0690: if (cl.findLoadedClass("java.lang.Object") != null) // XXX: Here we
0691: // differ of others. Is it
0692: // absolutely
0693: // acceptible
0694: // and
0695: // correct???
0696: assertTrue("Error5", cl.findLoadedClass(
0697: "java.lang.Object").getName().equals(
0698: "java.lang.Object"));
0699: } catch (Throwable e) {
0700: fail("Error6: " + e.toString());
0701: }
0702:
0703: // TEST CASE #5:
0704: try {
0705: cl.findLoadedClass("void");
0706: } catch (Throwable e) {
0707: fail("Error10: " + e.toString());
0708: }
0709:
0710: // // TEST CASE #8:
0711: // try {
0712: // //Class c =
0713: // Class.forName("[[[Ljavax.imageio.plugins.jpeg.JPEGImageReadParam;",
0714: // true, tcl);
0715: // Class c =
0716: // Class.forName("javax.imageio.plugins.jpeg.JPEGImageReadParamXXX",
0717: // true, tcl);
0718: // ///Class c =
0719: // tcl.loadClass("#javax.imageio.plugins.jpeg.JPEGImageReadParam");
0720: // System.out.println(c);
0721: // tcl.findLoadedClass("javax.imageio.plugins.jpeg.JPEGImageReadParam");
0722: // assertTrue("Error7",
0723: // tcl.findLoadedClass("javax.imageio.plugins.jpeg.JPEGImageReadParam").getName().equals("javax.imageio.plugins.jpeg.JPEGImageReadParam"));
0724: // ///fail("Error11");
0725: // } catch (Throwable e) {
0726: // fail("Error12: " + e.toString());
0727: // }
0728:
0729: }
0730:
0731: /**
0732: * FIXME invalid test: only VM can initiate loading class
0733: */
0734: public void te_st_findLoadedClass_Str_2() {
0735: // TEST CASE #4:
0736: try {
0737: Class c = Class.forName("java.lang.ClassLoaderTest$7LCL",
0738: true, ClassLoader.getSystemClassLoader());
0739: assertTrue("Error7", ClassLoader.getSystemClassLoader()
0740: .findLoadedClass("java.lang.ClassLoaderTest$7LCL")
0741: .getName().equals("java.lang.ClassLoaderTest$7LCL"));
0742: } catch (Throwable e) {
0743: fail("Error8: " + e.toString());
0744: }
0745:
0746: // TEST CASE #6:
0747: try {
0748: Class c = Class.forName("[B", true, ClassLoader
0749: .getSystemClassLoader());
0750: assertTrue("Error7", ClassLoader.getSystemClassLoader()
0751: .findLoadedClass("[B") == null); // if the element type is a primitive type, then the array class has no class loader
0752: } catch (Throwable e) {
0753: fail("Error12: " + e.toString());
0754: }
0755:
0756: // TEST CASE #6_1:
0757: try {
0758: ClassLoader ld = TestResources.getLoader();
0759: Class c = Class.forName(
0760: "[Lorg.apache.harmony.lang.generics.TemplateSet;",
0761: true, ld);
0762: assertTrue(
0763: "Error7_1",
0764: ld
0765: .findLoadedClass("[Lorg.apache.harmony.test.TestResources;") == null); // according the delegate loading model
0766: } catch (Throwable e) {
0767: fail("Error12_1: " + e.toString());
0768: }
0769:
0770: // TEST CASE #6_2:
0771: try {
0772: try {
0773: Class c = Class.forName("I", true, ClassLoader
0774: .getSystemClassLoader()); // If name denotes a primitive type or void, an attempt will be made to
0775: // locate a user-defined class in the unnamed package whose name is name.
0776: // Therefore, this method cannot be used to obtain any of the Class
0777: // objects representing primitive types or void.
0778: assertTrue("Error7_2",
0779: ClassLoader.getSystemClassLoader()
0780: .findLoadedClass("I") == null);
0781: } catch (ClassNotFoundException e) {
0782: //System.out.println("I1: "+e.toString());
0783: }
0784: try {
0785: Class c = Class.forName("int", true, ClassLoader
0786: .getSystemClassLoader()); // If name denotes a primitive type or void, an attempt will be made to
0787: // locate a user-defined class in the unnamed package whose name is name.
0788: // Therefore, this method cannot be used to obtain any of the Class
0789: // objects representing primitive types or void.
0790: assertTrue("Error7_2",
0791: ClassLoader.getSystemClassLoader()
0792: .findLoadedClass("int") == null);
0793: } catch (ClassNotFoundException e) {
0794: //System.out.println("I2: "+e.toString());
0795: }
0796: try {
0797: ClassLoader ld = TestResources.getLoader();
0798: //ClassLoader ld = ClassLoader.getSystemClassLoader();
0799: //System.out.println("I3: "+int.class.getName()+"|"+int.class.getClassLoader());
0800: Class c = ld.loadClass("int");
0801: assertTrue("Error7_2",
0802: ld.findLoadedClass("int") == null);
0803: } catch (ClassNotFoundException e) {
0804: //System.out.println("I4: "+e.toString());
0805: }
0806: } catch (Throwable e) {
0807: fail("Error12_2: " + e.toString());
0808: }
0809:
0810: // TEST CASE #7:
0811: try {
0812: Class c = Class.forName("[[[Ljava.lang.Object;", false,
0813: ClassLoader.getSystemClassLoader());
0814: ClassLoader.getSystemClassLoader().findLoadedClass(
0815: "[[[Ljava.lang.Object;");
0816: assertTrue("Error7", ClassLoader.getSystemClassLoader()
0817: .findLoadedClass("[[[Ljava.lang.Object;") == null);
0818: } catch (Throwable e) {
0819: fail("Error12: " + e.toString());
0820: }
0821:
0822: try {
0823: // "public class bbb{} // (javac 1.5)":
0824: byte[] clazz = { -54, -2, -70, -66, 0, 0, 0, 49, 0, 13, 10,
0825: 0, 3, 0, 10, 7, 0, 11, 7, 0, 12, 1, 0, 6, 60, 105,
0826: 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4,
0827: 67, 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, 78,
0828: 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0,
0829: 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101,
0830: 1, 0, 8, 98, 98, 98, 46, 106, 97, 118, 97, 12, 0,
0831: 4, 0, 5, 1, 0, 3, 98, 98, 98, 1, 0, 16, 106, 97,
0832: 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106,
0833: 101, 99, 116, 0, 33, 0, 2, 0, 3, 0, 0, 0, 0, 0, 1,
0834: 0, 1, 0, 4, 0, 5, 0, 1, 0, 6, 0, 0, 0, 29, 0, 1, 0,
0835: 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 1, 0,
0836: 7, 0, 0, 0, 6, 0, 1, 0, 0, 0, 1, 0, 1, 0, 8, 0, 0,
0837: 0, 2, 0, 9 };
0838: FileOutputStream fos;
0839: fos = new FileOutputStream(new File(System
0840: .getProperty("java.ext.dirs")
0841: + File.separator
0842: + "classes"
0843: + File.separator
0844: + "bbb.class"));
0845: for (int i = 0; i < clazz.length; i++) {
0846: fos.write((byte) clazz[i]);
0847: }
0848: fos.flush();
0849: fos.close();
0850: } catch (IOException e) {
0851: System.out
0852: .println("TEST test_findLoadedClass_Str, CASE #10, DIDN'T RUN"
0853: + e.toString());
0854: }
0855:
0856: // TEST CASE #9
0857: try {
0858: ClassLoader chain = ClassLoader.getSystemClassLoader();
0859: while (chain.getParent() != null) {
0860: chain = chain.getParent();
0861: }
0862: Class c = Class.forName("bbb", false, chain); // loading via the Capital ClassLoader
0863: assertTrue(chain.findLoadedClass("bbb").getName().equals(
0864: "bbb"));
0865: } catch (ClassNotFoundException e) {
0866: System.out
0867: .println("TEST test_findLoadedClass_Str, CASE #10, DIDN'T RUN"
0868: + e.toString());
0869: } catch (Exception e) {
0870: fail("TEST test_findLoadedClass_Str, CASE #9, FAILED"
0871: + e.toString());
0872: }
0873:
0874: // TEST CASE #10
0875: class LCL2 extends ClassLoader {
0876: public Class findClass(String name)
0877: throws ClassNotFoundException {
0878: return super .findClass(name);
0879: }
0880:
0881: public LCL2() {
0882: super ();
0883: }
0884: }
0885:
0886: LCL2 tcl2 = new LCL2();
0887:
0888: try {
0889: Class c = Class.forName("bbb", false, tcl2);
0890: ClassLoader chain = tcl2;
0891: while (chain.getParent() != null) {
0892: if (chain.findLoadedClass("bbb") != null
0893: && chain.findLoadedClass("bbb").getName()
0894: .equals("bbb")) {
0895: //System.out.println("TEST PASSED");
0896: return;
0897: }
0898: chain = chain.getParent();
0899: }
0900: assertTrue(chain.findLoadedClass("bbb") != null
0901: && chain.findLoadedClass("bbb").getName().equals(
0902: "bbb"));
0903: } catch (ClassNotFoundException e) {
0904: System.out
0905: .println("TEST test_findLoadedClass_Str, CASE #10, DIDN'T RUN");
0906: } catch (Exception e) {
0907: fail("TEST test_findLoadedClass_Str, CASE #10, FAILED(2)");
0908: }
0909: }
0910:
0911: /**
0912: *
0913: */
0914: public void test_findLoadedClass_Str_3() {
0915:
0916: class testCL extends ClassLoader {
0917: public int res = 0;
0918:
0919: public testCL() {
0920: super ();
0921: res = 0;
0922: }
0923:
0924: public Class loadClass(String nm)
0925: throws ClassNotFoundException {
0926: if ("java.lang.ClassLoaderTest$1a3".equals(nm)) {
0927: res += 1;
0928: }
0929: return super .loadClass(nm);
0930: }
0931:
0932: public Class fndLoadedClass(String nm) {
0933: return super .findLoadedClass(nm);
0934: }
0935: }
0936: class a3 extends ClassLoader {
0937: public a3() {
0938: super ();
0939: }
0940:
0941: public void main(String[] args) {
0942: try {
0943: new a3().test(args);
0944: } catch (Throwable e) {
0945: e.printStackTrace();
0946: }
0947: }
0948:
0949: public int test(String[] args) throws Exception {
0950: testCL cl = new testCL();
0951: for (int i = 0; i < 10; i++) {
0952: int t = (this .callClass(cl)).intValue();
0953: if (t != 104) {
0954: // System.out.println("Test failed step "+i+": method result = "+t);
0955: return 105;
0956: }
0957: }
0958: assertTrue(cl.fndLoadedClass(
0959: "java.lang.ClassLoaderTest$1a3").getName()
0960: .equals("java.lang.ClassLoaderTest$1a3"));
0961: return 104;
0962: }
0963:
0964: private Integer callClass(testCL cLoader) throws Exception {
0965: Class cls = Class.forName(
0966: "java.lang.ClassLoaderTest$1a3", true, cLoader);
0967: Method mm = cls.getMethod("test", (Class[]) null);
0968: return (Integer) mm.invoke(this , new Object[0]);
0969: }
0970:
0971: public int test() {
0972: return 104;
0973: }
0974: }
0975: // FIXME invalid test: only VM can initiate loading class
0976: //new a3().main(new String[] { "" });
0977: }
0978:
0979: /**
0980: *
0981: */
0982: public void test_findResource_Str() {
0983: class LCL extends ClassLoader {
0984: // only for special case
0985:
0986: public Class<?> findClass(String name) {
0987: return null;
0988: }
0989:
0990: public java.net.URL findResource(String name) {
0991: String nm = name.replace('.', '/');
0992: return this .getClass().getResource("/" + nm + ".class");
0993: }
0994:
0995: public LCL() {
0996: super ();
0997: }
0998: }
0999:
1000: LCL tcl = new LCL();
1001: // TEST CASE #2:
1002: assertTrue("Error1",
1003: tcl.findResource("java.lang.Class") != null);
1004:
1005: // TEST CASE #2:
1006: try {
1007: assertTrue("Error2", ClassLoader.getSystemClassLoader()
1008: .findResources("java.lang.Class") != null);
1009: } catch (java.io.IOException _) {
1010: fail("Error3");
1011: }
1012: }
1013:
1014: /**
1015: *
1016: */
1017: public void test_findResources_Str() {
1018: class LCL extends ClassLoader {
1019: // only for special case
1020:
1021: public Class<?> findClass(String name) {
1022: return null;
1023: }
1024:
1025: public java.util.Enumeration<URL> findResources(String name)
1026: throws java.io.IOException {
1027: return super .findResources(name);
1028: }
1029:
1030: public LCL() {
1031: super ();
1032: }
1033: }
1034:
1035: LCL tcl = new LCL();
1036: // TEST CASE #1:
1037: try {
1038: assertTrue("Error1",
1039: tcl.findResources("java.lang.Class") != null);
1040: } catch (java.io.IOException _) {
1041: fail("Error2");
1042: }
1043:
1044: // TEST CASE #2:
1045: try {
1046: ClassLoader.getSystemClassLoader().findResource(
1047: "java.lang.Class");
1048: } catch (Exception _) {
1049: fail("Error3");
1050: }
1051:
1052: try {
1053: tcl.findResources(null);
1054: } catch (NullPointerException _) {
1055: fail("Error5");
1056: } catch (java.io.IOException _) {
1057: }
1058: }
1059:
1060: /**
1061: *
1062: */
1063: public void test_findSystemClass_Str() {
1064: class LCL extends ClassLoader {
1065: // only for special case
1066:
1067: public Class<?> findClass(String name) {
1068: return null;
1069: }
1070:
1071: public LCL() {
1072: super ();
1073: }
1074: }
1075:
1076: LCL tcl = new LCL();
1077: // TEST CASE #1:
1078: try {
1079: assertTrue("Error1",
1080: tcl.findSystemClass("java.lang.Class") != null);
1081: } catch (ClassNotFoundException _) {
1082: fail("Error2");
1083: }
1084:
1085: // TEST CASE #2:
1086: try {
1087: ClassLoader.getSystemClassLoader().findSystemClass(
1088: "java.lang.Class");
1089: } catch (ClassNotFoundException _) {
1090: fail("Error3");
1091: }
1092:
1093: // TEST CASE #3:
1094: try {
1095: ClassLoader.getSystemClassLoader().getSystemClassLoader()
1096: .getSystemClassLoader().findSystemClass(
1097: "java.lang.Class");
1098: } catch (ClassNotFoundException _) {
1099: fail("Error4");
1100: }
1101:
1102: // TEST CASE #4:
1103: try {
1104: ClassLoader.getSystemClassLoader().findSystemClass(null);
1105: fail("Error5");
1106: } catch (ClassNotFoundException _) {
1107: fail("Error6");
1108: } catch (NullPointerException _) {
1109: }
1110: }
1111:
1112: /**
1113: *
1114: */
1115: public void test_getPackage_Str() {
1116: ClassLoader cl = ClassLoader.getSystemClassLoader();
1117:
1118: // TEST CASE #1:
1119: try {
1120: cl.getPackage(null);
1121: fail("Error1");
1122: } catch (NullPointerException _) {
1123: }
1124:
1125: // TEST CASE #2:
1126: assertTrue("Error1",
1127: cl.getPackage("UNEXISTED.Unknown.Package") == null);
1128:
1129: // TEST CASE #3:
1130: try {
1131: cl.definePackage("javax", "ZSSspecTitle1",
1132: "ZSSspecVersion1", "ZSSspecVendor1",
1133: "ZSSimplTitle1", "ZSSimplVersion1",
1134: "ZSSimplVendor1", new java.net.URL(
1135: "http://intel.com/"));
1136: cl.definePackage("javax.imageio", "ZSSspecTitle2",
1137: "ZSSspecVersion2", "ZSSspecVendor2",
1138: "ZSSimplTitle2", "ZSSimplVersion2",
1139: "ZSSimplVendor2", new java.net.URL(
1140: "http://intel.com/"));
1141: try {
1142: Class c1 = cl.loadClass("javax.imageio.ImageIO");
1143: try {
1144: c1.newInstance(); // to be initialized
1145: } catch (Exception _) {
1146: }
1147: assertTrue("Error1", cl.getPackage("javax.imageio")
1148: .getName().equals("javax.imageio"));
1149: assertTrue("Error2", cl.getPackage("javax.imageio")
1150: .getSpecificationTitle()
1151: .equals("ZSSspecTitle2"));
1152: assertTrue("Error3", cl.getPackage("javax.imageio")
1153: .getSpecificationVersion().equals(
1154: "ZSSspecVersion2"));
1155: assertTrue("Error4", cl.getPackage("javax.imageio")
1156: .getSpecificationVendor().equals(
1157: "ZSSspecVendor2"));
1158: assertTrue("Error5", cl.getPackage("javax.imageio")
1159: .getImplementationTitle().equals(
1160: "ZSSimplTitle2"));
1161: assertTrue("Error6", cl.getPackage("javax.imageio")
1162: .getImplementationVersion().equals(
1163: "ZSSimplVersion2"));
1164: assertTrue("Error7", cl.getPackage("javax.imageio")
1165: .getImplementationVendor().equals(
1166: "ZSSimplVendor2"));
1167: assertTrue("Error8", cl.getPackage("javax").getName()
1168: .equals("javax"));
1169: assertTrue("Error9", cl.getPackage("javax")
1170: .getSpecificationTitle()
1171: .equals("ZSSspecTitle1"));
1172: assertTrue("Error10", cl.getPackage("javax")
1173: .getSpecificationVersion().equals(
1174: "ZSSspecVersion1"));
1175: assertTrue("Error11", cl.getPackage("javax")
1176: .getSpecificationVendor().equals(
1177: "ZSSspecVendor1"));
1178: assertTrue("Error12", cl.getPackage("javax")
1179: .getImplementationTitle().equals(
1180: "ZSSimplTitle1"));
1181: assertTrue("Error13", cl.getPackage("javax")
1182: .getImplementationVersion().equals(
1183: "ZSSimplVersion1"));
1184: assertTrue("Error14", cl.getPackage("javax")
1185: .getImplementationVendor().equals(
1186: "ZSSimplVendor1"));
1187: } catch (ClassNotFoundException _) {
1188: System.out.println("ClassNotFoundException 1");
1189: }
1190: } catch (java.net.MalformedURLException _) {
1191: }
1192: }
1193:
1194: /**
1195: *
1196: */
1197: public void test_getPackages_V() {
1198: class LCL extends ClassLoader {
1199: // only for special case
1200:
1201: public Class<?> findClass(String name)
1202: throws ClassNotFoundException {
1203: return super .findClass(name);
1204: }
1205:
1206: public LCL() {
1207: super ();
1208: }
1209:
1210: public LCL(ClassLoader cl) {
1211: super (cl);
1212: }
1213: }
1214: ClassLoader cl = ClassLoader.getSystemClassLoader();
1215: int loadersNumber = 11; //20;
1216: int pkgsPerLoader = 21; //30;
1217: ClassLoader acl[] = new ClassLoader[loadersNumber];
1218: ClassLoader prevcl = new LCL(cl);
1219:
1220: // TEST CASE #1:
1221: for (int i = 0; i < loadersNumber; i++) {
1222: acl[i] = new LCL(prevcl);
1223: prevcl = acl[i];
1224: }
1225: for (int i = 0; i < loadersNumber; i++) {
1226: for (int j = 0; j < pkgsPerLoader; j++) {
1227: try {
1228: String curLable = Integer.toString(i) + "_"
1229: + Integer.toString(j);
1230: acl[i].definePackage(curLable, "ZSSspecTitle"
1231: + curLable, "ZSSspecVersion" + curLable,
1232: "ZSSspecVendor" + curLable, "ZSSimplTitle"
1233: + curLable, "ZSSimplVersion"
1234: + curLable, "ZSSimplVendor"
1235: + curLable, new java.net.URL(
1236: "http://intel.com/"));
1237: } catch (java.net.MalformedURLException _) {
1238: }
1239: }
1240: }
1241: int res = 0;
1242: int prevLen = 0;
1243: int tmp = 0;
1244: for (int i = 0; i < loadersNumber; i++) {
1245: assertTrue("Error1",
1246: (tmp = acl[i].getPackages().length) > prevLen);
1247: prevLen = tmp;
1248: for (int j = 0; j < acl[i].getPackages().length; j++) {
1249: if (acl[i].getPackages()[j].getName().equals(
1250: Integer.toString(i) + "_"
1251: + Integer.toString(pkgsPerLoader - 1))) {
1252: res++;
1253: assertTrue(
1254: "Error2",
1255: acl[i].getPackages()[j]
1256: .getSpecificationTitle()
1257: .equals(
1258: "ZSSspecTitle"
1259: + Integer
1260: .toString(i)
1261: + "_"
1262: + Integer
1263: .toString(pkgsPerLoader - 1)));
1264: assertTrue(
1265: "Error3",
1266: acl[i].getPackages()[j]
1267: .getSpecificationVersion()
1268: .equals(
1269: "ZSSspecVersion"
1270: + Integer
1271: .toString(i)
1272: + "_"
1273: + Integer
1274: .toString(pkgsPerLoader - 1)));
1275: assertTrue(
1276: "Error4",
1277: acl[i].getPackages()[j]
1278: .getSpecificationVendor()
1279: .equals(
1280: "ZSSspecVendor"
1281: + Integer
1282: .toString(i)
1283: + "_"
1284: + Integer
1285: .toString(pkgsPerLoader - 1)));
1286: assertTrue(
1287: "Error5",
1288: acl[i].getPackages()[j]
1289: .getImplementationTitle()
1290: .equals(
1291: "ZSSimplTitle"
1292: + Integer
1293: .toString(i)
1294: + "_"
1295: + Integer
1296: .toString(pkgsPerLoader - 1)));
1297: assertTrue(
1298: "Error6",
1299: acl[i].getPackages()[j]
1300: .getImplementationVersion()
1301: .equals(
1302: "ZSSimplVersion"
1303: + Integer
1304: .toString(i)
1305: + "_"
1306: + Integer
1307: .toString(pkgsPerLoader - 1)));
1308: assertTrue(
1309: "Error7",
1310: acl[i].getPackages()[j]
1311: .getImplementationVendor()
1312: .equals(
1313: "ZSSimplVendor"
1314: + Integer
1315: .toString(i)
1316: + "_"
1317: + Integer
1318: .toString(pkgsPerLoader - 1)));
1319: break;
1320: }
1321: }
1322: }
1323: assertTrue("Error8", res == loadersNumber);
1324: }
1325:
1326: /**
1327: *
1328: */
1329: public void test_getParent_V() {
1330: class LCL extends ClassLoader {
1331: // only for special case
1332:
1333: public Class<?> findClass(String name)
1334: throws ClassNotFoundException {
1335: return super .findClass(name);
1336: }
1337:
1338: public LCL() {
1339: super ();
1340: }
1341:
1342: public LCL(ClassLoader cl) {
1343: super (cl);
1344: }
1345: }
1346: ClassLoader cl = ClassLoader.getSystemClassLoader();
1347: int loadersNumber = 1000;
1348: ClassLoader acl[] = new ClassLoader[loadersNumber];
1349: ClassLoader prevcl = cl;
1350:
1351: // TEST CASE #1:
1352: for (int i = 0; i < loadersNumber; i++) {
1353: acl[i] = new LCL(prevcl);
1354: prevcl = acl[i];
1355: }
1356: for (int i = loadersNumber - 1; i > -1; i--) {
1357: if (i != 0) {
1358: assertTrue("Error1", acl[i].getParent().equals(
1359: acl[i - 1]));
1360: } else {
1361: assertTrue("Error2", acl[i].getParent().equals(cl));
1362: }
1363: }
1364: }
1365:
1366: /**
1367: *
1368: */
1369: public void test_getResource_Str() {
1370: ClassLoader cl = ClassLoader.getSystemClassLoader();
1371:
1372: // TEST CASE #1:
1373: try {
1374: cl.getResource(null);
1375: fail("Error1: NullPointerException is not thrown for null argument");
1376: } catch (NullPointerException _) {
1377: }
1378:
1379: // TEST CASE #2:
1380: assertTrue("Error1: unexpected:"
1381: + cl.getResource("java/lang/Class.class").toString(),
1382: cl.getResource("java/lang/Class.class").toString()
1383: .indexOf("java/lang/Class.class") != -1);
1384:
1385: // TEST CASE #3:
1386: if (vendor.equals("Intel DRL")) {
1387: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1388: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1389: // should be passed for ij.exe for real check
1390: String as[] = System.getProperty(
1391: (vendor.equals("Intel DRL") ? "vm" : "sun")
1392: + ".boot.class.path").split(
1393: System.getProperty("path.separator"));
1394: for (int i = 0; i < as.length; i++) {
1395: File f = new File(as[i]);
1396: if (f.exists() && f.isFile()
1397: && f.getName().endsWith(".jar")) {
1398: try {
1399: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1400: f);
1401: for (java.util.Enumeration e = jf.entries(); e
1402: .hasMoreElements();) {
1403: String s = e.nextElement().toString();
1404: if (s.endsWith(".class")) {
1405: assertTrue("Error1", cl.getResource(s)
1406: .toString().indexOf(s) != -1);
1407: return;
1408: }
1409: }
1410: } catch (java.io.IOException _) {
1411: }
1412: } else if (f.exists() && f.isDirectory() && false) {
1413: String afn[] = f.list();
1414: File aff[] = f.listFiles();
1415: for (int j = 0; j < aff.length; j++) {
1416: if (aff[j].isFile()) {
1417: assertTrue("Error1", cl.getResource(afn[j])
1418: .toString().indexOf(afn[j]) != -1);
1419: return;
1420: }
1421: }
1422: }
1423: }
1424: }
1425: }
1426:
1427: /**
1428: *
1429: */
1430: public void test_getResourceAsStream_Str() {
1431: ClassLoader cl = ClassLoader.getSystemClassLoader();
1432:
1433: // TEST CASE #1:
1434: try {
1435: cl.getResourceAsStream(null);
1436: fail("Error1: NullPointerException is not thrown for null argument");
1437: } catch (NullPointerException _) {
1438: }
1439:
1440: // TEST CASE #2:
1441: byte magic[] = new byte[4];
1442: try {
1443: cl.getResourceAsStream("java/lang/Class.class").read(magic);
1444: assertTrue("Error1", new String(magic).equals(new String(
1445: new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA,
1446: (byte) 0xBE })));
1447: } catch (java.io.IOException _) {
1448: }
1449:
1450: // TEST CASE #3:
1451: if (vendor.equals("Intel DRL")) {
1452: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1453: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1454: // should be passed for ij.exe for real check
1455: String as[] = System.getProperty(
1456: (vendor.equals("Intel DRL") ? "vm" : "sun")
1457: + ".boot.class.path").split(
1458: System.getProperty("path.separator"));
1459: for (int i = 0; i < as.length; i++) {
1460: File f = new File(as[i]);
1461: if (f.exists() && f.isFile()
1462: && f.getName().endsWith(".jar")) {
1463: try {
1464: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1465: f);
1466: for (java.util.Enumeration e = jf.entries(); e
1467: .hasMoreElements();) {
1468: String s = e.nextElement().toString();
1469: if (s.endsWith(".class")) {
1470: magic = new byte[4];
1471: try {
1472: cl.getResourceAsStream(s).read(
1473: magic);
1474: assertTrue("Error1", new String(
1475: magic).equals(new String(
1476: new byte[] { (byte) 0xCA,
1477: (byte) 0xFE,
1478: (byte) 0xBA,
1479: (byte) 0xBE })));
1480: } catch (java.io.IOException _) {
1481: }
1482: return;
1483: }
1484: }
1485: } catch (java.io.IOException _) {
1486: }
1487: } else if (f.exists() && f.isDirectory() && false) {
1488: String afn[] = f.list();
1489: File aff[] = f.listFiles();
1490: for (int j = 0; j < aff.length; j++) {
1491: if (aff[j].isFile()) {
1492: try {
1493: assertTrue("Error1", cl
1494: .getResourceAsStream(afn[j])
1495: .available() >= 0);
1496: } catch (java.io.IOException _) {
1497: }
1498: return;
1499: }
1500: }
1501: }
1502: }
1503: }
1504: }
1505:
1506: /**
1507: *
1508: */
1509: public void test_getResources_Str() {
1510: ClassLoader cl = ClassLoader.getSystemClassLoader();
1511:
1512: // TEST CASE #1:
1513: try {
1514: cl.getResources(null);
1515: assertTrue("Error1", cl.getResources(null)
1516: .hasMoreElements() == false);
1517: } catch (NullPointerException _) {
1518: } catch (java.io.IOException _) {
1519: }
1520:
1521: // TEST CASE #2:
1522: try {
1523: assertTrue("Error2: unexpected:"
1524: + cl.getResources("java/lang/ClassLoader.class")
1525: .nextElement(), ((java.net.URL) cl
1526: .getResources("java/lang/ClassLoader.class")
1527: .nextElement()).toString().indexOf(
1528: "java/lang/ClassLoader.class") != -1);
1529: //java.util.Enumeration e =
1530: // cl.getResources("java/lang/ClassLoader.class");
1531: //assertTrue("Error2: unexpected:"
1532: // + cl.getResources("/meta-inf/Manifest.mf").nextElement(),
1533: // ((java.net.URL)cl.getResources("/meta-inf/Manifest.mf").nextElement()).toString().indexOf(
1534: // "/meta-inf/Manifest.mf") != -1);
1535: //e = cl.getResources("/meta-inf/Manifest.mf");
1536: //System.out.println(e.nextElement());
1537: //System.out.println(e.nextElement());
1538: //System.out.println(e.nextElement());
1539: } catch (java.io.IOException _) {
1540: }
1541:
1542: // TEST CASE #3:
1543: if (vendor.equals("Intel DRL")) {
1544: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1545: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1546: // should be passed for ij.exe for real check
1547: String as[] = System.getProperty(
1548: (vendor.equals("Intel DRL") ? "vm" : "sun")
1549: + ".boot.class.path").split(
1550: System.getProperty("path.separator"));
1551: for (int i = 0; i < as.length; i++) {
1552: File f = new File(as[i]);
1553: if (f.exists() && f.isFile()
1554: && f.getName().endsWith(".jar")) {
1555: try {
1556: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1557: f);
1558: for (java.util.Enumeration e = jf.entries(); e
1559: .hasMoreElements();) {
1560: String s = e.nextElement().toString();
1561: if (s.endsWith(".class")) {
1562: assertTrue("Error3", ((java.net.URL) cl
1563: .getResources(s).nextElement())
1564: .toString().indexOf(s) != -1);
1565: return;
1566: }
1567: }
1568: } catch (java.io.IOException _) {
1569: }
1570: } else if (f.exists() && f.isDirectory() && false) {
1571: String afn[] = f.list();
1572: File aff[] = f.listFiles();
1573: for (int j = 0; j < aff.length; j++) {
1574: if (aff[j].isFile()) {
1575: try {
1576: assertTrue("Error4", ((java.net.URL) cl
1577: .getResources(afn[j])
1578: .nextElement()).toString()
1579: .indexOf(afn[j]) != -1);
1580: return;
1581: } catch (java.io.IOException _) {
1582: }
1583: }
1584: }
1585: }
1586: }
1587: }
1588: }
1589:
1590: /**
1591: *
1592: */
1593: public void test_getSystemClassLoader_V() {
1594: // TEST CASE #1:
1595: try {
1596: String jscl = System
1597: .getProperty("java.system.class.loader");
1598: if (jscl != null && jscl != "") {
1599: assertTrue("Error1", ClassLoader.getSystemClassLoader()
1600: .getClass().getName().equals(jscl));
1601: }
1602: java.util.Properties pl = System.getProperties();
1603: pl.setProperty("java.system.class.loader",
1604: "java.lang.ClassLoaderTest$TestClassLoader");
1605: System.setProperties(pl);
1606: jscl = System.getProperty("java.system.class.loader");
1607: if (jscl != null && jscl != "") {
1608: assertTrue("Error1 "
1609: + ClassLoader.getSystemClassLoader().getClass()
1610: .getName(), !ClassLoader
1611: .getSystemClassLoader().getClass().getName()
1612: .equals(jscl));
1613: }
1614: } catch (NullPointerException _) {
1615: }
1616: }
1617:
1618: /**
1619: *
1620: */
1621: public void test_getSystemResource_Str() {
1622: ClassLoader.getSystemClassLoader();
1623:
1624: // TEST CASE #1:
1625: try {
1626: ClassLoader.getSystemResource(null);
1627: fail("Error1: NullPointerException is not thrown for null argument");
1628: } catch (NullPointerException _) {
1629: }
1630:
1631: // TEST CASE #2:
1632: assertTrue("Error1: unexpected:"
1633: + ClassLoader.getSystemResource("java/lang/Void.class")
1634: .toString(), ClassLoader.getSystemResource(
1635: "java/lang/Void.class").toString().indexOf(
1636: "java/lang/Void.class") != -1);
1637:
1638: // TEST CASE #3:
1639: if (vendor.equals("Intel DRL")) {
1640: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1641: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1642: // should be passed for ij.exe for real check
1643: String as[] = System.getProperty(
1644: (vendor.equals("Intel DRL") ? "vm" : "sun")
1645: + ".boot.class.path").split(
1646: System.getProperty("path.separator"));
1647: for (int i = 0; i < as.length; i++) {
1648: File f = new File(as[i]);
1649: if (f.exists() && f.isFile()
1650: && f.getName().endsWith(".jar")) {
1651: try {
1652: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1653: f);
1654: for (java.util.Enumeration e = jf.entries(); e
1655: .hasMoreElements();) {
1656: String s = e.nextElement().toString();
1657: if (s.endsWith(".class")) {
1658: assertTrue("Error1", ClassLoader
1659: .getSystemResource(s)
1660: .toString().indexOf(s) != -1);
1661: return;
1662: }
1663: }
1664: } catch (java.io.IOException _) {
1665: }
1666: } else if (f.exists() && f.isDirectory() && false) {
1667: String afn[] = f.list();
1668: File aff[] = f.listFiles();
1669: for (int j = 0; j < aff.length; j++) {
1670: if (aff[j].isFile()) {
1671: assertTrue("Error1", ClassLoader
1672: .getSystemResource(afn[j])
1673: .toString().indexOf(afn[j]) != -1);
1674: return;
1675: }
1676: }
1677: }
1678: }
1679: }
1680: }
1681:
1682: /**
1683: *
1684: */
1685: public void test_getSystemResourceAsStream_Str() {
1686: ClassLoader.getSystemClassLoader();
1687:
1688: // TEST CASE #1:
1689: try {
1690: ClassLoader.getSystemResourceAsStream(null);
1691: fail("Error1: NullPointerException is not thrown for null argument");
1692: } catch (NullPointerException _) {
1693: }
1694:
1695: // TEST CASE #2:
1696: byte magic[] = new byte[4];
1697: try {
1698: ClassLoader.getSystemResourceAsStream(
1699: "java/lang/reflect/Method.class").read(magic);
1700: assertTrue("Error1", new String(magic).equals(new String(
1701: new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA,
1702: (byte) 0xBE })));
1703: } catch (java.io.IOException _) {
1704: }
1705:
1706: // TEST CASE #3:
1707: if (vendor.equals("Intel DRL")) {
1708: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1709: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1710: // should be passed for ij.exe for real check
1711: String as[] = System.getProperty(
1712: (vendor.equals("Intel DRL") ? "vm" : "sun")
1713: + ".boot.class.path").split(
1714: System.getProperty("path.separator"));
1715: for (int i = 0; i < as.length; i++) {
1716: File f = new File(as[i]);
1717: if (f.exists() && f.isFile()
1718: && f.getName().endsWith(".jar")) {
1719: try {
1720: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1721: f);
1722: for (java.util.Enumeration e = jf.entries(); e
1723: .hasMoreElements();) {
1724: String s = e.nextElement().toString();
1725: if (s.endsWith(".class")) {
1726: magic = new byte[4];
1727: try {
1728: ClassLoader
1729: .getSystemResourceAsStream(
1730: s).read(magic);
1731: assertTrue("Error1", new String(
1732: magic).equals(new String(
1733: new byte[] { (byte) 0xCA,
1734: (byte) 0xFE,
1735: (byte) 0xBA,
1736: (byte) 0xBE })));
1737: } catch (java.io.IOException _) {
1738: }
1739: return;
1740: }
1741: }
1742: } catch (java.io.IOException _) {
1743: }
1744: } else if (f.exists() && f.isDirectory() && false) {
1745: String afn[] = f.list();
1746: File aff[] = f.listFiles();
1747: for (int j = 0; j < aff.length; j++) {
1748: if (aff[j].isFile()) {
1749: try {
1750: assertTrue(
1751: "Error1",
1752: ClassLoader
1753: .getSystemResourceAsStream(
1754: afn[j])
1755: .available() >= 0);
1756: } catch (java.io.IOException _) {
1757: }
1758: return;
1759: }
1760: }
1761: }
1762: }
1763: }
1764: }
1765:
1766: /**
1767: *
1768: */
1769: public void test_getSystemResources_Str() {
1770: ClassLoader cl = ClassLoader.getSystemClassLoader();
1771:
1772: // TEST CASE #1:
1773: try {
1774: ClassLoader.getSystemResources(null);
1775: assertTrue("Error1", cl.getResources(null)
1776: .hasMoreElements() == false);
1777: } catch (NullPointerException _) {
1778: } catch (java.io.IOException _) {
1779: }
1780:
1781: // TEST CASE #2:
1782: try {
1783: assertTrue("Error2: unexpected:"
1784: + ClassLoader.getSystemResources(
1785: "java/lang/ClassLoader.class")
1786: .nextElement(), ((java.net.URL) ClassLoader
1787: .getSystemResources("java/lang/ClassLoader.class")
1788: .nextElement()).toString().indexOf(
1789: "java/lang/ClassLoader.class") != -1);
1790: } catch (java.io.IOException _) {
1791: }
1792:
1793: // TEST CASE #3:
1794: if (vendor.equals("Intel DRL")) {
1795: // -Xbootclasspath[/a /p]:<some non-empty path list> or
1796: // -D{vm/sun}.boot.class.path=<some non-empty path list> arguments
1797: // should be passed for ij.exe for real check
1798: String as[] = System.getProperty(
1799: (vendor.equals("Intel DRL") ? "vm" : "sun")
1800: + ".boot.class.path").split(
1801: System.getProperty("path.separator"));
1802: for (int i = 0; i < as.length; i++) {
1803: File f = new File(as[i]);
1804: if (f.exists() && f.isFile()
1805: && f.getName().endsWith(".jar")) {
1806: try {
1807: java.util.jar.JarFile jf = new java.util.jar.JarFile(
1808: f);
1809: for (java.util.Enumeration e = jf.entries(); e
1810: .hasMoreElements();) {
1811: String s = e.nextElement().toString();
1812: if (s.endsWith(".class")) {
1813: assertTrue(
1814: "Error3",
1815: ((java.net.URL) ClassLoader
1816: .getSystemResources(s)
1817: .nextElement())
1818: .toString().indexOf(s) != -1);
1819: return;
1820: }
1821: }
1822: } catch (java.io.IOException _) {
1823: }
1824: } else if (f.exists() && f.isDirectory() && false) {
1825: String afn[] = f.list();
1826: File aff[] = f.listFiles();
1827: for (int j = 0; j < aff.length; j++) {
1828: if (aff[j].isFile()) {
1829: try {
1830: assertTrue("Error4",
1831: ((java.net.URL) ClassLoader
1832: .getSystemResources(
1833: afn[j])
1834: .nextElement())
1835: .toString().indexOf(
1836: afn[j]) != -1);
1837: return;
1838: } catch (java.io.IOException _) {
1839: }
1840: }
1841: }
1842: }
1843: }
1844: }
1845: }
1846:
1847: /**
1848: *
1849: */
1850: public void test_loadClass_Str() {
1851: class LC1 {
1852: class LC2 {
1853: class LC3 {
1854: class LC4 {
1855: class LC5 {
1856: class LC6 {
1857: class LC7 {
1858: class LC8 {
1859: class LC9 {
1860: class LC10 {
1861: class LC11 {
1862: class LC12 {
1863: class LC13 {
1864: class LC14 {
1865: class LC15 {
1866: class LC16 {
1867: class LC17 {
1868: class LC18 {
1869: class LC19 {
1870: class LC20
1871: extends
1872: LC19 {
1873: class LC21 {
1874: public LC21() {
1875: System.out
1876: .println("1 LC21");
1877: }
1878: }
1879: }
1880: }
1881: }
1882: }
1883: }
1884: }
1885: }
1886: }
1887: }
1888: }
1889: }
1890: }
1891: }
1892: }
1893: }
1894: }
1895: }
1896: }
1897: }
1898: }
1899: //TestClassLoader tcl = new TestClassLoader();
1900: ClassLoader tcl = ClassLoader.getSystemClassLoader();
1901: try {
1902: Class c = ((ClassLoader) tcl)
1903: .loadClass("java.lang.ClassLoaderTest$1LC1$LC2$LC3$LC4$LC5$LC6$LC7$LC8$LC9$LC10$LC11$LC12$LC13$LC14$LC15$LC16$LC17$LC18$LC19$LC20$LC21");
1904: c.newInstance();
1905: fail("Error1 ");
1906: } catch (ClassNotFoundException _) {
1907: fail("Error2");
1908: } catch (InstantiationException e) {
1909: } catch (Exception e) {
1910: fail("Error3");
1911: }
1912: }
1913:
1914: /**
1915: *
1916: */
1917: public void test_loadClass_Str_Z() {
1918: class LC1 {
1919: class LC2 {
1920: class LC3 {
1921: class LC4 {
1922: class LC5 {
1923: class LC6 {
1924: class LC7 {
1925: class LC8 {
1926: class LC9 {
1927: class LC10 {
1928: class LC11 {
1929: class LC12 {
1930: class LC13 {
1931: class LC14 {
1932: class LC15 {
1933: class LC16 {
1934: class LC17 {
1935: class LC18 {
1936: class LC19 {
1937: class LC20
1938: extends
1939: LC19 {
1940: class LC21 {
1941: public LC21() {
1942: System.out
1943: .println("2 LC21");
1944: }
1945: }
1946: }
1947: }
1948: }
1949: }
1950: }
1951: }
1952: }
1953: }
1954: }
1955: }
1956: }
1957: }
1958: }
1959: }
1960: }
1961: }
1962: }
1963: }
1964: }
1965:
1966: public LC1() {
1967: System.out.println("1");
1968: }
1969: }
1970: String longName = "java.lang.ClassLoaderTest$2LC1$LC2$LC3$LC4$LC5$LC6$LC7$LC8$LC9$LC10$LC11$LC12$LC13$LC14$LC15$LC16$LC17$LC18$LC19$LC20$LC21";
1971: TestClassLoader tcl = new TestClassLoader();
1972: ClassLoader cl = ClassLoader.getSystemClassLoader();
1973: String pices[] = longName.split("\\$");
1974: String curClNm = pices[0] + "$" + pices[1];
1975: Class c;
1976: for (int i = 2; i < pices.length; i++) {
1977: curClNm = curClNm + "$" + pices[i];
1978: try {
1979: if (i % 2 == 0) {
1980: c = ((ClassLoader) tcl).loadClass(curClNm, true);
1981: } else {
1982: c = cl.loadClass(curClNm, true);
1983: }
1984: try {
1985: c.newInstance();
1986: } catch (Exception e) {
1987: }
1988: } catch (ClassNotFoundException _) {
1989: fail("Error1: " + curClNm);
1990: } catch (Exception e) {
1991: fail("Error2 " + e.toString());
1992: }
1993: }
1994: }
1995:
1996: /**
1997: *
1998: */
1999: Class tmpCl;
2000:
2001: int tmpI;
2002:
2003: public void test_loadClass_Str_Z_1() {
2004: class LC1 {
2005: class LC2 {
2006: class LC3 {
2007: class LC4 {
2008: class LC5 {
2009: class LC6 {
2010: class LC7 {
2011: class LC8 {
2012: class LC9 {
2013: class LC10 {
2014: class LC11 {
2015: class LC12 {
2016: class LC13 {
2017: class LC14 {
2018: class LC15 {
2019: class LC16 {
2020: class LC17 {
2021: class LC18 {
2022: class LC19 {
2023: class LC20
2024: extends
2025: LC19 {
2026: class LC21 {
2027: public LC21() {
2028: System.out
2029: .println("3 LC21");
2030: }
2031: }
2032: }
2033: }
2034: }
2035: }
2036: }
2037: }
2038: }
2039: }
2040: }
2041: }
2042: }
2043: }
2044: }
2045: }
2046: }
2047: }
2048: }
2049: }
2050:
2051: public LC2() {
2052: System.out.println("1");
2053: }
2054: }
2055:
2056: public LC1() {
2057: System.out.println("1");
2058: }
2059: }
2060: class ConcurentLoader extends Thread {
2061: public String clN;
2062:
2063: public ClassLoader l;
2064:
2065: public void run() {
2066: try {
2067: if (clN.length() == tmpI) {
2068: tmpCl = ((ClassLoader) l).loadClass(clN, false);
2069: } else {
2070: ((ClassLoader) l).loadClass(clN, false);
2071: }
2072: } catch (ClassNotFoundException _) {
2073: fail("Error1");
2074: }
2075: }
2076: }
2077: String longName = "java.lang.ClassLoaderTest$3LC1$LC2$LC3$LC4$LC5$LC6$LC7$LC8$LC9$LC10$LC11$LC12$LC13$LC14$LC15$LC16$LC17$LC18$LC19$LC20$LC21";
2078: tmpI = longName.length();
2079: TestClassLoader tcl = new TestClassLoader();
2080: ClassLoader cl = ClassLoader.getSystemClassLoader();
2081: String pices[] = longName.split("\\$");
2082: String curClNm = pices[0] + "$" + pices[1];
2083: ConcurentLoader[] thr = new ConcurentLoader[pices.length];
2084: for (int i = 2; i < pices.length; i++) {
2085: curClNm = curClNm + "$" + pices[i];
2086: try {
2087: thr[i] = new ConcurentLoader();
2088: thr[i].clN = curClNm;
2089: if (i % 2 == 0) {
2090: thr[i].l = ((ClassLoader) tcl);
2091: } else {
2092: thr[i].l = ((ClassLoader) cl);
2093: }
2094: } catch (Exception e) {
2095: fail("Error2 " + e.toString());
2096: }
2097: }
2098: for (int i = 2; i < pices.length; i++) {
2099: thr[i].start();
2100: }
2101: for (int i = 2; i < pices.length; i++) {
2102: try {
2103: thr[i].join();
2104: } catch (InterruptedException e) {
2105: fail("Error2 ");
2106: }
2107: }
2108: try {
2109: tmpCl.newInstance();
2110: } catch (InstantiationException e) {
2111: //System.out.println("Warning: "+e.toString());
2112: //try {
2113: // Class.forName(longName).newInstance();
2114: //} catch (Exception ee) {
2115: // System.out.println("Warning: "+ee.toString());
2116: // try {
2117: // Class.forName("java.lang.ClassLoaderTest$3$LC1").newInstance();
2118: // } catch (Exception eee) {
2119: // System.out.println("Warning: "+eee.toString());
2120: // }
2121: //}
2122: } catch (Exception e) {
2123: fail("Error3: " + e.toString());
2124: }
2125: }
2126:
2127: /**
2128: *
2129: */
2130: public void test_resolveClass_Cla() {
2131:
2132: // TEST CASE #1:
2133: TestClassLoader tcl = new TestClassLoader();
2134: ((ClassLoader) tcl).resolveClass(int.class);
2135:
2136: // TEST CASE #2:
2137: try {
2138: ClassLoader.getSystemClassLoader().resolveClass(null);
2139: } catch (NullPointerException _) {
2140: }
2141:
2142: // TEST CASE #2:
2143: try {
2144: Number i[][][] = new Number[1][2][3];
2145: ClassLoader.getSystemClassLoader().resolveClass(
2146: i.getClass());
2147: } catch (NullPointerException _) {
2148: }
2149: }
2150:
2151: /**
2152: *
2153: */
2154: public void test_setClassAssertionStatus_Str_Z() {
2155: TestClassLoader tcl = new TestClassLoader();
2156: ((ClassLoader) tcl).setClassAssertionStatus(";^)", true);
2157:
2158: ClassLoader cl = Class.class.getClassLoader();
2159: if (cl == null)
2160: cl = ClassLoader.getSystemClassLoader();
2161: cl.setClassAssertionStatus("javax.xml.transform.sax.SAXSource",
2162: true);
2163: try {
2164: Class c = cl.loadClass("javax.xml.transform.sax.SAXSource");
2165: try {
2166: c.newInstance(); // to be initialized
2167: } catch (Exception _) {
2168: }
2169: assertTrue("Error1:", c.desiredAssertionStatus() == c
2170: .desiredAssertionStatus()); // "this method is not
2171: // guaranteed to return the
2172: // actual assertion status"
2173: } catch (ClassNotFoundException _) {
2174: System.out.println("ClassNotFoundException 1");
2175: }
2176:
2177: ((ClassLoader) tcl).setClassAssertionStatus(
2178: "javax.xml.transform.sax.SAXTransformerFactory", true);
2179: try {
2180: Class c = tcl
2181: .loadClass("#javax.xml.transform.sax.SAXTransformerFactory");
2182: assertTrue("Error2", c.desiredAssertionStatus() == c
2183: .desiredAssertionStatus());
2184: } catch (ClassNotFoundException _) {
2185: }
2186: ((ClassLoader) tcl).setClassAssertionStatus(
2187: "javax.xml.transform.sax.SAXTransformerFactory", false);
2188: try {
2189: Class c = tcl
2190: .loadClass("javax.xml.transform.sax.SAXTransformerFactory");
2191: assertTrue("Error3", c.desiredAssertionStatus() == c
2192: .desiredAssertionStatus());
2193: } catch (ClassNotFoundException _) {
2194: System.out.println("ClassNotFoundException");
2195: }
2196: ((ClassLoader) tcl).setClassAssertionStatus(
2197: "javax.xml.transform.sax.SAXTransformerFactory", true);
2198: ((ClassLoader) tcl).setClassAssertionStatus(
2199: "javax.xml.transform.sax.SAXTransformerFactory", false);
2200:
2201: if (cl == null)
2202: cl = ClassLoader.getSystemClassLoader();
2203: cl.setClassAssertionStatus(
2204: "[Ljavax.xml.transform.sax.SAXTransformerFactory;",
2205: true);
2206: try {
2207: //Class c =
2208: // Class.forName("[Ljavax.xml.transform.sax.SAXTransformerFactory;",
2209: // false, cl);
2210: // //try {
2211: // // Object o = c.newInstance(); // to be initialized
2212: // //} catch(Exception e) {System.out.println("Exception 2:"+e);}
2213: //assertTrue("Error4:", c.desiredAssertionStatus() ==
2214: // c.desiredAssertionStatus() ); // "this method is not guaranteed
2215: // to return the actual assertion status"
2216: Class c = Class.forName(
2217: "[Ljavax.xml.transform.sax.SAXTransformerFactory;",
2218: true, cl);
2219: assertTrue("Error5:", c.desiredAssertionStatus() == c
2220: .desiredAssertionStatus()); // "this method is not
2221: // guaranteed to return the
2222: // actual assertion status"
2223: } catch (ClassNotFoundException _) {
2224: System.out.println("ClassNotFoundException 2");
2225: }
2226: }
2227:
2228: /**
2229: *
2230: */
2231: public void test_setDefaultAssertionStatus_Z() {
2232: TestClassLoader tcl = new TestClassLoader();
2233: ((ClassLoader) tcl).setDefaultAssertionStatus(true);
2234: ((ClassLoader) tcl).setDefaultAssertionStatus(false);
2235: ((ClassLoader) tcl).setDefaultAssertionStatus(true);
2236: ((ClassLoader) tcl).setDefaultAssertionStatus(false);
2237: }
2238:
2239: /**
2240: *
2241: */
2242: public void test_setPackageAssertionStatus_Str_Z() {
2243: TestClassLoader tcl = new TestClassLoader();
2244: ((ClassLoader) tcl).setPackageAssertionStatus(":^(", true);
2245:
2246: ClassLoader cl = Class.class.getClassLoader();
2247: if (cl == null)
2248: cl = ClassLoader.getSystemClassLoader();
2249: cl
2250: .setPackageAssertionStatus(
2251: "javax.xml.transform.stream", true);
2252: try {
2253: Class c = cl
2254: .loadClass("javax.xml.transform.stream.StreamSource");
2255: try {
2256: c.newInstance(); // to be initialized
2257: } catch (Exception _) {
2258: //System.out.println("(test_setPackageAssertionStatus_Str_Z)Exception
2259: // 1");
2260: }
2261: assertTrue("Error1:", c.desiredAssertionStatus() == c
2262: .desiredAssertionStatus()); // "this method is not
2263: // guaranteed to return the
2264: // actual assertion status"
2265: } catch (ClassNotFoundException _) {
2266: System.out.println("ClassNotFoundException 1");
2267: }
2268:
2269: ((ClassLoader) tcl).setPackageAssertionStatus(
2270: "javax.xml.transform.sax", true);
2271: ((ClassLoader) tcl).setPackageAssertionStatus(
2272: "javax.xml.transform.sax", false);
2273: ((ClassLoader) tcl).setPackageAssertionStatus("", true);
2274: ((ClassLoader) tcl).setPackageAssertionStatus("", false);
2275: }
2276:
2277: /**
2278: *
2279: */
2280: public void test_setSigners_Cla_ObjArr() {
2281:
2282: // TEST CASE #1:
2283: TestClassLoader tcl = new TestClassLoader();
2284: ((ClassLoader) tcl).setSigners(int.class, (Object[]) null);
2285:
2286: // TEST CASE #2:
2287: ((ClassLoader) tcl)
2288: .setSigners(int.class, new Object[] { null });
2289:
2290: // TEST CASE #3:
2291: try {
2292: ((ClassLoader) tcl).setSigners(null, new Object[] { "" });
2293: fail("Error1");
2294: } catch (NullPointerException _) {
2295: }
2296:
2297: // TEST CASE #4:
2298: ClassLoader.getSystemClassLoader().setSigners(int.class,
2299: (Object[]) null);
2300:
2301: // TEST CASE #5:
2302: ClassLoader.getSystemClassLoader().setSigners(int.class,
2303: new Object[] { null });
2304:
2305: // TEST CASE #6:
2306: try {
2307: ClassLoader.getSystemClassLoader().setSigners(null,
2308: new Object[] { "" });
2309: fail("Error1");
2310: } catch (NullPointerException _) {
2311: }
2312:
2313: // TEST CASE #7:
2314: ClassLoader.getSystemClassLoader().setSigners(int.class,
2315: (Object[]) null);
2316:
2317: // TEST CASE #8:
2318: Number i[][][] = new Number[1][2][3];
2319: ClassLoader.getSystemClassLoader().setSigners(i.getClass(),
2320: (Object[]) null);
2321: }
2322:
2323: /*
2324: * Regression test for HARMONY-877
2325: * [classlib][lang] compatibility: Harmony method
2326: * ClassLoader.getResource(null) returns null while RI throws NPE
2327: *
2328: */
2329: public void test_HARMONY_877() {
2330: boolean et = false;
2331: try {
2332: ClassLoader.getSystemClassLoader().getResource(null);
2333: } catch (NullPointerException e) {
2334: et = true;
2335: }
2336: assertTrue("NullPointerException expected (case 1)", et);
2337: et = false;
2338:
2339: try {
2340: ClassLoader.getSystemClassLoader()
2341: .getResourceAsStream(null);
2342: } catch (NullPointerException e) {
2343: et = true;
2344: }
2345: assertTrue("NullPointerException expected (case 2)", et);
2346: }
2347:
2348: /*
2349: * Regression test for HARMONY-885
2350: * [classlib][core][drlvm] unexpected LinkageError for ClassLoader.defineClass
2351: *
2352: */
2353: public void test_HARMONY_885() {
2354: try {
2355: byte[] array0 = new byte[] { 2, 2, 2, 2, 2, 2 };
2356: new CL().defineKlass(array0, 0, 3);
2357: fail("exception expected");
2358: } catch (ClassFormatError e) {
2359: //expected
2360: }
2361: }
2362:
2363: private class CL extends ClassLoader {
2364: public Class defineKlass(byte[] a, int i1, int i2)
2365: throws ClassFormatError {
2366: return super.defineClass(a, i1, i2);
2367: }
2368: }
2369: }
|