001: /**
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */package org.apache.geronimo.kernel;
017:
018: import java.util.Set;
019: import java.util.LinkedHashSet;
020: import java.io.Serializable;
021:
022: import junit.framework.TestCase;
023: import org.apache.geronimo.kernel.basic.BasicKernel;
024:
025: /**
026: * Unit test for {@link org.apache.geronimo.kernel.ClassLoading} class.
027: *
028: * @version $Rev: 476049 $ $Date: 2006-11-16 20:35:17 -0800 (Thu, 16 Nov 2006) $
029: */
030: public class ClassloadingTest extends TestCase {
031: public void testLoadClass_Null() {
032: try {
033: ClassLoading.loadClass(
034: "org.apache.geronimo.kernel.ClassLoading", null);
035: fail("Expected NullArgumentException");
036: } catch (IllegalArgumentException ignore) {
037: } catch (ClassNotFoundException e) {
038: fail("Class should have been found: " + e);
039: }
040: }
041:
042: public void testLoadClass_Simple() {
043: String className = "org.apache.geronimo.kernel.ClassLoading";
044: Class type = loadClass(className);
045: assertEquals(className, type.getName());
046: }
047:
048: public void testLoadClass_Primitives() {
049: String className = "boolean";
050: Class type = loadClass(className);
051: assertEquals(className, type.getName());
052: }
053:
054: public void testLoadClass_VMPrimitives() {
055: String className = "B";
056: Class type = loadClass(className);
057: assertEquals(byte.class, type);
058: }
059:
060: public void testLoadClass_VMClassSyntax() {
061: String className = "org.apache.geronimo.kernel.ClassLoading";
062: Class type = loadClass("L" + className + ";");
063: assertEquals(className, type.getName());
064: }
065:
066: public void testLoadClass_VMArraySyntax() {
067: String className = "[B";
068: Class type = loadClass(className);
069: assertEquals(byte[].class, type);
070:
071: className = "[java.lang.String";
072: type = loadClass(className);
073: assertEquals(String[].class, type);
074: }
075:
076: public void testLoadClass_UserFriendlySyntax() {
077: String className = "I[]";
078: Class type = loadClass(className);
079: assertEquals(int[].class, type);
080:
081: className = "I[][][]";
082: type = loadClass(className);
083: assertEquals(int[][][].class, type);
084: }
085:
086: public void testgetClassName() throws ClassNotFoundException {
087: Class t;
088: Class y;
089: String x;
090:
091: t = String.class;
092: x = ClassLoading.getClassName(t);
093: y = loadClass(x);
094: assertEquals(t, y);
095:
096: t = int.class;
097: x = ClassLoading.getClassName(t);
098: y = loadClass(x);
099: assertEquals(t, y);
100:
101: t = String[].class;
102: x = ClassLoading.getClassName(t);
103: y = loadClass(x);
104: assertEquals(t, y);
105:
106: t = int[].class;
107: x = ClassLoading.getClassName(t);
108: y = loadClass(x);
109: assertEquals(t, y);
110:
111: t = String[][].class;
112: x = ClassLoading.getClassName(t);
113: y = loadClass(x);
114: assertEquals(t, y);
115:
116: t = int[][].class;
117: x = ClassLoading.getClassName(t);
118: y = loadClass(x);
119: assertEquals(t, y);
120:
121: }
122:
123: public void testGetAllTypes() throws Exception {
124: Set allTypes = ClassLoading.getAllTypes(MockGBean.class);
125: assertTrue(allTypes.contains(MockGBean.class));
126: assertTrue(allTypes.contains(Object.class));
127: assertTrue(allTypes.contains(MockEndpoint.class));
128: assertTrue(allTypes.contains(MockParentInterface1.class));
129: assertTrue(allTypes.contains(MockParentInterface2.class));
130: assertTrue(allTypes.contains(MockChildInterface1.class));
131: assertTrue(allTypes.contains(MockChildInterface2.class));
132: assertFalse(allTypes.contains(Comparable.class));
133: }
134:
135: public void testReduceInterfaces() throws Exception {
136: Set types = new LinkedHashSet();
137:
138: // single class
139: types.add(MockGBean.class);
140: types = ClassLoading.reduceInterfaces(types);
141: assertTrue(types.contains(MockGBean.class));
142: assertFalse(types.contains(Object.class));
143: assertFalse(types.contains(MockEndpoint.class));
144: assertFalse(types.contains(MockParentInterface1.class));
145: assertFalse(types.contains(MockParentInterface2.class));
146: assertFalse(types.contains(MockChildInterface1.class));
147: assertFalse(types.contains(MockChildInterface2.class));
148: assertFalse(types.contains(Comparable.class));
149:
150: // all types
151: types = ClassLoading.getAllTypes(MockGBean.class);
152: types = ClassLoading.reduceInterfaces(types);
153: assertTrue(types.contains(MockGBean.class));
154: assertFalse(types.contains(Object.class));
155: assertFalse(types.contains(MockEndpoint.class));
156: assertFalse(types.contains(MockParentInterface1.class));
157: assertFalse(types.contains(MockParentInterface2.class));
158: assertFalse(types.contains(MockChildInterface1.class));
159: assertFalse(types.contains(MockChildInterface2.class));
160: assertFalse(types.contains(Comparable.class));
161:
162: // double all types
163: types = ClassLoading.getAllTypes(MockGBean.class);
164: types.addAll(ClassLoading.getAllTypes(MockGBean.class));
165: types = ClassLoading.reduceInterfaces(types);
166: assertTrue(types.contains(MockGBean.class));
167: assertFalse(types.contains(Object.class));
168: assertFalse(types.contains(MockEndpoint.class));
169: assertFalse(types.contains(MockParentInterface1.class));
170: assertFalse(types.contains(MockParentInterface2.class));
171: assertFalse(types.contains(MockChildInterface1.class));
172: assertFalse(types.contains(MockChildInterface2.class));
173: assertFalse(types.contains(Comparable.class));
174:
175: // extra interfaces
176: types = ClassLoading.getAllTypes(MockGBean.class);
177: types.addAll(ClassLoading.getAllTypes(Kernel.class));
178: types.addAll(ClassLoading.getAllTypes(Serializable.class));
179: types = ClassLoading.reduceInterfaces(types);
180: assertTrue(types.contains(Kernel.class));
181: assertTrue(types.contains(Serializable.class));
182: assertTrue(types.contains(MockGBean.class));
183: assertFalse(types.contains(Object.class));
184: assertFalse(types.contains(MockEndpoint.class));
185: assertFalse(types.contains(MockParentInterface1.class));
186: assertFalse(types.contains(MockParentInterface2.class));
187: assertFalse(types.contains(MockChildInterface1.class));
188: assertFalse(types.contains(MockChildInterface2.class));
189: assertFalse(types.contains(Comparable.class));
190:
191: // two different types
192: types = ClassLoading.getAllTypes(MockGBean.class);
193: try {
194: types.addAll(ClassLoading.getAllTypes(BasicKernel.class));
195: } catch (IllegalArgumentException e) {
196: // expected
197: }
198: }
199:
200: private Class loadClass(String name) {
201: Class type = null;
202:
203: try {
204: type = ClassLoading.loadClass(name, getClass()
205: .getClassLoader());
206: } catch (ClassNotFoundException e) {
207: fail("Class should have been found: " + e);
208: }
209:
210: assertNotNull(type);
211:
212: return type;
213: }
214: }
|