[jboss-cvs] JBossAS SVN: r96653 - in projects/jboss-classpool/trunk/src/test: java/org/jboss/test/classpool/support and 1 other directories.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Fri Nov 20 14:54:00 EST 2009
Author: flavia.rainone at jboss.com
Date: 2009-11-20 14:54:00 -0500 (Fri, 20 Nov 2009)
New Revision: 96653
Removed:
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTestDelegate.java
Modified:
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithHierarchicalParentLoaderSanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithModuleDependencySanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithPackageDependencySanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportModuleSanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportPackageSanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithRepositorySanityTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithHierarchicalParentLoaderTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithModuleDependencyTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithPackageDependencyTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportModuleTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportPackageTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReplaceReferencesTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithRepositoryTestCase.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTest.java
projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/support/TestVFSClassLoaderFactoryFactory.java
projects/jboss-classpool/trunk/src/test/resources/org/jboss/test/classpool/jbosscl/Common.xml
Log:
[JBREFLECT-67] Cleaned up JBossClClassPoolTest and subclasses.
Deleted: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -1,53 +0,0 @@
-/*
-* JBoss, Home of Professional Open Source.
-* Copyright 2006, Red Hat Middleware LLC, and individual contributors
-* as indicated by the @author tags. See the copyright.txt file in the
-* distribution for a full listing of individual contributors.
-*
-* This is free software; you can redistribute it and/or modify it
-* under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation; either version 2.1 of
-* the License, or (at your option) any later version.
-*
-* This software is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public
-* License along with this software; if not, write to the Free
-* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-*/
-package org.jboss.test.classpool.jbosscl.test;
-
-import org.jboss.test.classpool.support.AlwaysWritablePermissionCollectionTestPolicyPlugin;
-
-/**
- *
- * @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
- * @version $Revision$
- */
-public class AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate extends JBossClClassPoolTestDelegate
-{
- public AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate(Class<?> clazz) throws Exception
- {
- super(clazz);
- }
-
- @Override
- protected void setUpSecurity() throws Exception
- {
- AlwaysWritablePermissionCollectionTestPolicyPlugin.initialisePlugin();
- super.setUpSecurity();
- }
-
- @Override
- public void tearDownSecurity() throws Exception
- {
- super.tearDownSecurity();
- AlwaysWritablePermissionCollectionTestPolicyPlugin.cleanupPlugin();
- }
-
-
-}
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithHierarchicalParentLoaderSanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithHierarchicalParentLoaderSanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithHierarchicalParentLoaderSanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -102,8 +102,8 @@
{
final String parentName = "parent";
final String childName = "child";
- ClassLoaderDomain parent = getSystem().createAndRegisterDomain(parentName, parentParentPolicy);
- ClassLoaderDomain child = getSystem().createAndRegisterDomain(childName, childParentPolicy, parent);
+ ClassLoaderDomain parent = system.createAndRegisterDomain(parentName, parentParentPolicy);
+ ClassLoaderDomain child = system.createAndRegisterDomain(childName, childParentPolicy, parent);
ClassLoader parentLoader = null;
ClassLoader childLoader = null;
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithModuleDependencySanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithModuleDependencySanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithModuleDependencySanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -65,7 +65,7 @@
clA = createClassLoader(resultA, "A", builderA, JAR_A_1);
Class<?> aFromA = assertLoadClass(CLASS_A, clA, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
ClassLoader clB = null;
Result resultB = new Result();
@@ -78,7 +78,7 @@
Class<?> aFromA1 = assertLoadClass(CLASS_A, clA, clA);
assertSame(aFromA, aFromA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertLoadClass(CLASS_B, clB, clB);
Class<?> aFromB = assertLoadClass(CLASS_A, clB, clA);
assertSame(aFromA, aFromB);
@@ -89,7 +89,7 @@
}
Class<?> aFromA1 = assertLoadClass(CLASS_A, clA);
assertSame(aFromA, aFromA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertNoClassLoader(resultB);
}
finally
@@ -110,7 +110,7 @@
createPackage(PACKAGE_A);
clA = createClassLoader(resultA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
ClassLoader clB = null;
Result resultB = new Result();
@@ -122,7 +122,7 @@
clB = createClassLoader(resultB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertLoadClass(CLASS_B, clB);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
@@ -135,7 +135,7 @@
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -155,7 +155,7 @@
createPackage(PACKAGE_A);
clA = createClassLoader(resultA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
Result resultB = new Result();
try
{
@@ -172,7 +172,7 @@
}
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertNoClassLoader(resultB);
}
finally
@@ -183,7 +183,7 @@
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -221,9 +221,9 @@
Class<?> classAX = assertLoadClass(CLASS_A, clAModuleX);
Class<?> classAA = assertLoadClass(CLASS_A, clAModuleA);
Class<?> classAY = assertLoadClass(CLASS_A, clAModuleY);
- assertCannotLoadClass(clAModuleX, CLASS_B);
- assertCannotLoadClass(clAModuleA, CLASS_B);
- assertCannotLoadClass(clAModuleY, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleX);
+ assertCannotLoadClass(CLASS_B, clAModuleA);
+ assertCannotLoadClass(CLASS_B, clAModuleY);
ClassLoader clB = null;
Result resultB = new Result();
@@ -239,9 +239,9 @@
assertSame(classAA, classAA1);
Class<?> classAY1 = assertLoadClass(CLASS_A, clAModuleY);
assertSame(classAY, classAY1);
- assertCannotLoadClass(clAModuleX, CLASS_B);
- assertCannotLoadClass(clAModuleA, CLASS_B);
- assertCannotLoadClass(clAModuleY, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleX);
+ assertCannotLoadClass(CLASS_B, clAModuleA);
+ assertCannotLoadClass(CLASS_B, clAModuleY);
assertLoadClass(CLASS_B, clB, clB);
Class<?> aFromB = assertLoadClass(CLASS_A, clB, clAModuleA);
@@ -259,9 +259,9 @@
assertSame(classAA, classAA1);
Class<?> classAY1 = assertLoadClass(CLASS_A, clAModuleY);
assertSame(classAY, classAY1);
- assertCannotLoadClass(clAModuleX, CLASS_B);
- assertCannotLoadClass(clAModuleA, CLASS_B);
- assertCannotLoadClass(clAModuleY, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleX);
+ assertCannotLoadClass(CLASS_B, clAModuleA);
+ assertCannotLoadClass(CLASS_B, clAModuleY);
}
finally
{
@@ -302,9 +302,9 @@
Class<?> classAX = assertLoadClass(CLASS_A, clAModuleA1);
Class<?> classAA = assertLoadClass(CLASS_A, clAModuleA2);
Class<?> classAY = assertLoadClass(CLASS_A, clAModuleA3);
- assertCannotLoadClass(clAModuleA1, CLASS_B);
- assertCannotLoadClass(clAModuleA2, CLASS_B);
- assertCannotLoadClass(clAModuleA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleA1);
+ assertCannotLoadClass(CLASS_B, clAModuleA2);
+ assertCannotLoadClass(CLASS_B, clAModuleA3);
ClassLoader clB = null;
Result rB = new Result();
@@ -320,9 +320,9 @@
assertSame(classAA, classAA1);
Class<?> classAY1 = assertLoadClass(CLASS_A, clAModuleA3);
assertSame(classAY, classAY1);
- assertCannotLoadClass(clAModuleA1, CLASS_B);
- assertCannotLoadClass(clAModuleA2, CLASS_B);
- assertCannotLoadClass(clAModuleA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleA1);
+ assertCannotLoadClass(CLASS_B, clAModuleA2);
+ assertCannotLoadClass(CLASS_B, clAModuleA3);
assertLoadClass(CLASS_B, clB, clB);
Class<?> aFromB = assertLoadClass(CLASS_A, clB, clAModuleA2);
@@ -340,9 +340,9 @@
assertSame(classAA, classAA1);
Class<?> classAY1 = assertLoadClass(CLASS_A, clAModuleA3);
assertSame(classAY, classAY1);
- assertCannotLoadClass(clAModuleA1, CLASS_B);
- assertCannotLoadClass(clAModuleA2, CLASS_B);
- assertCannotLoadClass(clAModuleA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clAModuleA1);
+ assertCannotLoadClass(CLASS_B, clAModuleA2);
+ assertCannotLoadClass(CLASS_B, clAModuleA3);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithPackageDependencySanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithPackageDependencySanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithPackageDependencySanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -64,7 +64,7 @@
createPackage(PACKAGE_A);
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -76,7 +76,7 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertLoadClass(CLASS_B, clB);
Class<?> aFromB = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, aFromB);
@@ -89,7 +89,7 @@
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -109,7 +109,7 @@
createPackage(PACKAGE_A, "1.0.0");
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -121,7 +121,7 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
assertLoadClass(CLASS_B, clB);
Class<?> aFromB = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, aFromB);
@@ -133,7 +133,7 @@
assertNoClassLoader(rB);
assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -153,7 +153,7 @@
createPackage(PACKAGE_A, "3.0.0");
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
Result rB = new Result();
try
@@ -171,7 +171,7 @@
}
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -179,7 +179,7 @@
}
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -217,9 +217,9 @@
Class<?> classA1 = assertLoadClass(CLASS_A, clA1);
Class<?> classA2 = assertLoadClass(CLASS_A, clA2);
Class<?> classA3 = assertLoadClass(CLASS_A, clA3);
- assertCannotLoadClass(clA1, CLASS_B);
- assertCannotLoadClass(clA2, CLASS_B);
- assertCannotLoadClass(clA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA1);
+ assertCannotLoadClass(CLASS_B, clA2);
+ assertCannotLoadClass(CLASS_B, clA3);
ClassLoader clB = null;
Result rB = new Result();
@@ -235,9 +235,9 @@
assertSame(classA2, classA21);
Class<?> classA31 = assertLoadClass(CLASS_A, clA3);
assertSame(classA3, classA31);
- assertCannotLoadClass(clA1, CLASS_B);
- assertCannotLoadClass(clA2, CLASS_B);
- assertCannotLoadClass(clA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA1);
+ assertCannotLoadClass(CLASS_B, clA2);
+ assertCannotLoadClass(CLASS_B, clA3);
assertLoadClass(CLASS_B, clB);
Class<?> classAFromB = assertLoadClass(CLASS_A, clB, clA2);
@@ -254,9 +254,9 @@
assertSame(classA2, classA21);
Class<?> classA31 = assertLoadClass(CLASS_A, clA3);
assertSame(classA3, classA31);
- assertCannotLoadClass(clA1, CLASS_B);
- assertCannotLoadClass(clA2, CLASS_B);
- assertCannotLoadClass(clA3, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA1);
+ assertCannotLoadClass(CLASS_B, clA2);
+ assertCannotLoadClass(CLASS_B, clA3);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportModuleSanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportModuleSanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportModuleSanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -63,8 +63,8 @@
createPackage(PACKAGE_A);
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -77,11 +77,11 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
assertLoadClass(CLASS_A, clB, clA);
Class<?> classB = assertLoadClass(CLASS_B, clB);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
ClassLoader clC = null;
Result rC = new Result();
@@ -93,13 +93,13 @@
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
classA1 = assertLoadClass(CLASS_A, clC, clA);
assertSame(classA, classA1);
classB1 = assertLoadClass(CLASS_B, clC, clB);
@@ -113,13 +113,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
}
finally
{
@@ -128,8 +128,8 @@
assertNoClassLoader(rB);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
}
finally
{
@@ -149,8 +149,8 @@
createPackage(PACKAGE_A);
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -163,12 +163,12 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB = assertLoadClass(CLASS_B, clB);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
ClassLoader clC = null;
Result rC = new Result();
@@ -180,14 +180,14 @@
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
- assertCannotLoadClass(clC, CLASS_A);
+ assertCannotLoadClass(CLASS_C, clB);
+ assertCannotLoadClass(CLASS_A, clC);
classB1 = assertLoadClass(CLASS_B, clC, clB);
assertSame(classB, classB1);
assertLoadClass(CLASS_C, clC);
@@ -199,13 +199,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
}
finally
{
@@ -214,8 +214,8 @@
assertNoClassLoader(rB);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportPackageSanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportPackageSanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithReExportPackageSanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -63,8 +63,8 @@
createPackage(PACKAGE_A);
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -78,12 +78,12 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB = assertLoadClass(CLASS_B, clB);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
ClassLoader clC = null;
Result rC = new Result();
@@ -95,13 +95,13 @@
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
classA1 = assertLoadClass(CLASS_A, clC, clA);
assertSame(classA, classA1);
classB1 = assertLoadClass(CLASS_B, clC, clB);
@@ -115,13 +115,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
classA1 = assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
}
finally
{
@@ -130,8 +130,8 @@
assertNoClassLoader(rB);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
}
finally
{
@@ -151,8 +151,8 @@
createPackage(PACKAGE_A);
clA = createClassLoader(rA, "A", builderA, JAR_A_1);
Class<?> classA = assertLoadClass(CLASS_A, clA);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
ClassLoader clB = null;
Result rB = new Result();
@@ -165,12 +165,12 @@
clB = createClassLoader(rB, "B", builderB, JAR_B_1);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB = assertLoadClass(CLASS_B, clB);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
ClassLoader clC = null;
Result rC = new Result();
@@ -182,14 +182,14 @@
assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
- assertCannotLoadClass(clC, CLASS_A);
+ assertCannotLoadClass(CLASS_C, clB);
+ assertCannotLoadClass(CLASS_A, clC);
classB1 = assertLoadClass(CLASS_B, clC, clB);
assertSame(classB, classB1);
assertLoadClass(CLASS_C, clC);
@@ -201,13 +201,13 @@
assertNoClassLoader(rC);
assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
assertLoadClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
Class<?> classB1 = assertLoadClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clB);
}
finally
{
@@ -216,8 +216,8 @@
assertNoClassLoader(rB);
Class<?> classA1 = assertLoadClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clA, CLASS_C);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_C, clA);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithRepositorySanityTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithRepositorySanityTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassLoaderWithRepositorySanityTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -31,6 +31,7 @@
import junit.framework.Test;
import org.jboss.classloader.spi.ClassLoaderDomain;
+import org.jboss.classloading.spi.dependency.Module;
/**
* Tests the behaviour of the new classloaders
@@ -82,13 +83,13 @@
Class<?> aFromA = clA.loadClass(CLASS_A);
assertNotNull(aFromA);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
unregisterClassLoader(clA);
}
- assertCannotLoadClass(getDefaultDomain(), CLASS_A);
+ assertCannotLoadClass(CLASS_A, system.getDefaultDomain());
}
public void testChildDomain() throws Exception
@@ -108,7 +109,7 @@
childDomain = getChildDomainForLoader(clC);
assertNotNull(childDomain);
- assertSame(getSystem().getDefaultDomain(), childDomain.getParent());
+ assertSame(system.getDefaultDomain(), childDomain.getParent());
Class<?> aFromA = clA.loadClass(CLASS_A);
assertNotNull(aFromA);
@@ -127,8 +128,8 @@
assertSame(clB, bFromB.getClassLoader());
assertSame(clC, cFromC.getClassLoader());
- assertCannotLoadClass(clA, CLASS_C);
- assertCannotLoadClass(clB, CLASS_C);
+ assertCannotLoadClass(CLASS_C, clA);
+ assertCannotLoadClass(CLASS_C, clB);
}
finally
{
@@ -154,18 +155,18 @@
domainA = getChildDomainForLoader(clA);
assertNotNull(domainA);
- assertSame(getSystem().getDefaultDomain(), domainA.getParent());
+ assertSame(system.getDefaultDomain(), domainA.getParent());
domainB = getChildDomainForLoader(clB);
assertNotNull(domainB);
- assertSame(getSystem().getDefaultDomain(), domainB.getParent());
+ assertSame(system.getDefaultDomain(), domainB.getParent());
assertNotSame(domainA, domainB);
Class<?> clazzA = clA.loadClass(CLASS_A);
assertSame(clA, clazzA.getClassLoader());
Class<?> clazzB = clB.loadClass(CLASS_B);
assertSame(clB, clazzB.getClassLoader());
- assertCannotLoadClass(clA, CLASS_B);
- assertCannotLoadClass(clB, CLASS_A);
+ assertCannotLoadClass(CLASS_B, clA);
+ assertCannotLoadClass(CLASS_A, clB);
}
finally
{
@@ -184,7 +185,7 @@
{
clScoped = createChildDomainParentFirstClassLoader("SCOPED", "SCOPED", true, JAR_B_1);
assertModule(clScoped);
- assertCannotLoadClass(clScoped, CLASS_A);
+ assertCannotLoadClass(CLASS_A, clScoped);
clGlobal = createClassLoader("GLOBAL", true, JAR_A_1);
assertModule(clScoped);
@@ -288,7 +289,7 @@
try
{
clA = createClassLoader("A", true, JAR_A_1);
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
clB = createClassLoader("B", true, JAR_B_1);
Class<?> bFromA = clA.loadClass(CLASS_B);
@@ -298,7 +299,7 @@
{
unregisterClassLoader(clB);
}
- assertCannotLoadClass(clA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, clA);
}
finally
{
@@ -317,10 +318,10 @@
try
{
globalA = createClassLoader("A", true, JAR_A_1);
- assertCannotLoadClass(globalA, CLASS_B);
+ assertCannotLoadClass(CLASS_B, globalA);
child = createChildDomainParentLastClassLoader("C", "C", true, JAR_C_1);
- assertCannotLoadClass(child, CLASS_B);
+ assertCannotLoadClass(CLASS_B, child);
globalB = createClassLoader("B", true, JAR_B_1);
Class<?> bFromChild = child.loadClass(CLASS_B);
@@ -332,7 +333,7 @@
{
unregisterClassLoader(globalB);
}
- assertCannotLoadClass(child, CLASS_B);
+ assertCannotLoadClass(CLASS_B, child);
}
finally
{
@@ -355,7 +356,7 @@
assertSame(parent, bFromGlobal.getClassLoader());
Class<?> bFromParent = parent.loadClass(CLASS_B);
assertSame(bFromGlobal, bFromParent);
- assertCannotLoadClass(parent, CLASS_A);
+ assertCannotLoadClass(CLASS_A, parent);
}
finally
{
@@ -380,7 +381,7 @@
assertSame(parent, bFromGlobal.getClassLoader());
Class<?> bFromParent = parent.loadClass(CLASS_B);
assertSame(bFromGlobal, bFromParent);
- assertCannotLoadClass(parent, CLASS_D);
+ assertCannotLoadClass(CLASS_D, parent);
Method method = dFromGlobal.getDeclaredMethod("getB");
assertSame(method.getReturnType(), bFromParent);
@@ -584,5 +585,10 @@
unregisterClassLoader(globalC);
}
}
-
-}
+
+ @Override
+ protected void registerModule(Module module)
+ {
+ domainRegistry.initMapsForModule(module);
+ }
+}
\ No newline at end of file
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithHierarchicalParentLoaderTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithHierarchicalParentLoaderTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithHierarchicalParentLoaderTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -102,8 +102,8 @@
{
final String parentName = "parent";
final String childName = "child";
- ClassLoaderDomain parent = getSystem().createAndRegisterDomain(parentName, parentParentPolicy);
- ClassLoaderDomain child = getSystem().createAndRegisterDomain(childName, childParentPolicy, parent);
+ ClassLoaderDomain parent = system.createAndRegisterDomain(parentName, parentParentPolicy);
+ ClassLoaderDomain child = system.createAndRegisterDomain(childName, childParentPolicy, parent);
ClassPool parentPool = null;
ClassPool childPool = null;
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithModuleDependencyTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithModuleDependencyTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithModuleDependencyTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -66,7 +66,7 @@
clA = createClassPool(resultA, "A", builderA, JAR_A_1);
CtClass aFromA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
ClassPool clB = null;
Result resultB = new Result();
@@ -79,7 +79,7 @@
CtClass aFromA1 = assertLoadCtClass(CLASS_A, clA, clA);
assertSame(aFromA, aFromA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertLoadCtClass(CLASS_B, clB, clB);
CtClass aFromB = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(aFromA, aFromB);
@@ -90,7 +90,7 @@
}
CtClass aFromA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(aFromA, aFromA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertNoClassLoader(resultB);
}
@@ -112,7 +112,7 @@
createPackage(PACKAGE_A);
clA = createClassPool(resultA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
ClassPool clB = null;
Result resultB = new Result();
@@ -124,7 +124,7 @@
clB = createClassPool(resultB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertLoadCtClass(CLASS_B, clB);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
@@ -136,7 +136,7 @@
assertNoClassLoader(resultB);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -156,7 +156,7 @@
createPackage(PACKAGE_A);
clA = createClassPool(resultA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
Result resultB = new Result();
try
{
@@ -173,7 +173,7 @@
}
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertNoClassLoader(resultB);
}
finally
@@ -184,7 +184,7 @@
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -223,9 +223,9 @@
CtClass classAX = assertLoadCtClass(CLASS_A, clAModuleX);
CtClass classAA = assertLoadCtClass(CLASS_A, clAModuleA);
CtClass classAY = assertLoadCtClass(CLASS_A, clAModuleY);
- assertCannotLoadCtClass(clAModuleX, CLASS_B);
- assertCannotLoadCtClass(clAModuleA, CLASS_B);
- assertCannotLoadCtClass(clAModuleY, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleX);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA);
+ assertCannotLoadCtClass(CLASS_B, clAModuleY);
ClassPool clB = null;
Result rB = new Result();
@@ -241,9 +241,9 @@
assertSame(classAA, classAA1);
CtClass classAY1 = assertLoadCtClass(CLASS_A, clAModuleY);
assertSame(classAY, classAY1);
- assertCannotLoadCtClass(clAModuleX, CLASS_B);
- assertCannotLoadCtClass(clAModuleA, CLASS_B);
- assertCannotLoadCtClass(clAModuleY, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleX);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA);
+ assertCannotLoadCtClass(CLASS_B, clAModuleY);
assertLoadCtClass(CLASS_B, clB, clB);
CtClass aFromB = assertLoadCtClass(CLASS_A, clB, clAModuleA);
@@ -261,9 +261,9 @@
assertSame(classAA, classAA1);
CtClass classAY1 = assertLoadCtClass(CLASS_A, clAModuleY);
assertSame(classAY, classAY1);
- assertCannotLoadCtClass(clAModuleX, CLASS_B);
- assertCannotLoadCtClass(clAModuleA, CLASS_B);
- assertCannotLoadCtClass(clAModuleY, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleX);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA);
+ assertCannotLoadCtClass(CLASS_B, clAModuleY);
}
finally
{
@@ -305,9 +305,9 @@
CtClass classAX = assertLoadCtClass(CLASS_A, clAModuleA1);
CtClass classAA = assertLoadCtClass(CLASS_A, clAModuleA2);
CtClass classAY = assertLoadCtClass(CLASS_A, clAModuleA3);
- assertCannotLoadCtClass(clAModuleA1, CLASS_B);
- assertCannotLoadCtClass(clAModuleA2, CLASS_B);
- assertCannotLoadCtClass(clAModuleA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA1);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA2);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA3);
ClassPool clB = null;
Result rB = new Result();
@@ -323,9 +323,9 @@
assertSame(classAA, classAA1);
CtClass classAY1 = assertLoadCtClass(CLASS_A, clAModuleA3);
assertSame(classAY, classAY1);
- assertCannotLoadCtClass(clAModuleA1, CLASS_B);
- assertCannotLoadCtClass(clAModuleA2, CLASS_B);
- assertCannotLoadCtClass(clAModuleA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA1);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA2);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA3);
assertLoadCtClass(CLASS_B, clB, clB);
CtClass aFromB = assertLoadCtClass(CLASS_A, clB, clAModuleA2);
@@ -343,9 +343,9 @@
assertSame(classAA, classAA1);
CtClass classAY1 = assertLoadCtClass(CLASS_A, clAModuleA3);
assertSame(classAY, classAY1);
- assertCannotLoadCtClass(clAModuleA1, CLASS_B);
- assertCannotLoadCtClass(clAModuleA2, CLASS_B);
- assertCannotLoadCtClass(clAModuleA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA1);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA2);
+ assertCannotLoadCtClass(CLASS_B, clAModuleA3);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithPackageDependencyTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithPackageDependencyTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithPackageDependencyTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -63,7 +63,7 @@
createPackage(PACKAGE_A);
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -75,7 +75,7 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertLoadCtClass(CLASS_B, clB);
CtClass aFromB = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, aFromB);
@@ -88,7 +88,7 @@
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -108,7 +108,7 @@
createPackage(PACKAGE_A, "1.0.0");
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -120,7 +120,7 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
assertLoadCtClass(CLASS_B, clB);
CtClass aFromB = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, aFromB);
@@ -132,7 +132,7 @@
assertNoClassLoader(rB);
assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -152,7 +152,7 @@
createPackage(PACKAGE_A, "3.0.0");
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
Result rB = new Result();
try
@@ -170,7 +170,7 @@
}
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -178,7 +178,7 @@
}
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA);
}
finally
{
@@ -216,9 +216,9 @@
CtClass classA1 = assertLoadCtClass(CLASS_A, clA1);
CtClass classA2 = assertLoadCtClass(CLASS_A, clA2);
CtClass classA3 = assertLoadCtClass(CLASS_A, clA3);
- assertCannotLoadCtClass(clA1, CLASS_B);
- assertCannotLoadCtClass(clA2, CLASS_B);
- assertCannotLoadCtClass(clA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA1);
+ assertCannotLoadCtClass(CLASS_B, clA2);
+ assertCannotLoadCtClass(CLASS_B, clA3);
ClassPool clB = null;
Result rB = new Result();
@@ -234,9 +234,9 @@
assertSame(classA2, classA21);
CtClass classA31 = assertLoadCtClass(CLASS_A, clA3);
assertSame(classA3, classA31);
- assertCannotLoadCtClass(clA1, CLASS_B);
- assertCannotLoadCtClass(clA2, CLASS_B);
- assertCannotLoadCtClass(clA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA1);
+ assertCannotLoadCtClass(CLASS_B, clA2);
+ assertCannotLoadCtClass(CLASS_B, clA3);
assertLoadCtClass(CLASS_B, clB);
CtClass classAFromB = assertLoadCtClass(CLASS_A, clB, clA2);
@@ -253,9 +253,9 @@
assertSame(classA2, classA21);
CtClass classA31 = assertLoadCtClass(CLASS_A, clA3);
assertSame(classA3, classA31);
- assertCannotLoadCtClass(clA1, CLASS_B);
- assertCannotLoadCtClass(clA2, CLASS_B);
- assertCannotLoadCtClass(clA3, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, clA1);
+ assertCannotLoadCtClass(CLASS_B, clA2);
+ assertCannotLoadCtClass(CLASS_B, clA3);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportModuleTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportModuleTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportModuleTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -63,8 +63,8 @@
createPackage(PACKAGE_A);
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -77,12 +77,12 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB = assertLoadCtClass(CLASS_B, clB);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
ClassPool clC = null;
Result rC = new Result();
@@ -94,13 +94,13 @@
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
classA1 = assertLoadCtClass(CLASS_A, clC, clA);
assertSame(classA, classA1);
classB1 = assertLoadCtClass(CLASS_B, clC, clB);
@@ -114,13 +114,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
}
finally
{
@@ -129,8 +129,8 @@
assertNoClassLoader(rB);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
}
finally
{
@@ -150,8 +150,8 @@
createPackage(PACKAGE_A);
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_B, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -164,12 +164,12 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB = assertLoadCtClass(CLASS_B, clB);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
ClassPool clC = null;
Result rC = new Result();
@@ -181,14 +181,14 @@
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_B, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
- assertCannotLoadCtClass(clC, CLASS_A);
+ assertCannotLoadCtClass(CLASS_C, clB);
+ assertCannotLoadCtClass(CLASS_A, clC);
classB1 = assertLoadCtClass(CLASS_B, clC, clB);
assertSame(classB, classB1);
assertLoadCtClass(CLASS_C, clC);
@@ -200,13 +200,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
}
finally
{
@@ -215,8 +215,8 @@
assertNoClassLoader(rB);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportPackageTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportPackageTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReExportPackageTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -63,8 +63,8 @@
createPackage(PACKAGE_A);
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -78,12 +78,12 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB = assertLoadCtClass(CLASS_B, clB);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
ClassPool clC = null;
Result rC = new Result();
@@ -95,13 +95,13 @@
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
classA1 = assertLoadCtClass(CLASS_A, clC, clA);
assertSame(classA, classA1);
classB1 = assertLoadCtClass(CLASS_B, clC, clB);
@@ -115,13 +115,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
}
finally
{
@@ -130,8 +130,8 @@
assertNoClassLoader(rB);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
}
finally
{
@@ -151,8 +151,8 @@
createPackage(PACKAGE_A);
clA = createClassPool(rA, "A", builderA, JAR_A_1);
CtClass classA = assertLoadCtClass(CLASS_A, clA);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
ClassPool clB = null;
Result rB = new Result();
@@ -165,12 +165,12 @@
clB = createClassPool(rB, "B", builderB, JAR_B_1);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB = assertLoadCtClass(CLASS_B, clB);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
ClassPool clC = null;
Result rC = new Result();
@@ -182,14 +182,14 @@
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
- assertCannotLoadCtClass(clC, CLASS_A);
+ assertCannotLoadCtClass(CLASS_C, clB);
+ assertCannotLoadCtClass(CLASS_A, clC);
classB1 = assertLoadCtClass(CLASS_B, clC, clB);
assertSame(classB, classB1);
assertLoadCtClass(CLASS_C, clC);
@@ -201,13 +201,13 @@
assertNoClassLoader(rC);
classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
classA1 = assertLoadCtClass(CLASS_A, clB, clA);
assertSame(classA, classA1);
CtClass classB1 = assertLoadCtClass(CLASS_B, clB);
assertSame(classB, classB1);
- assertCannotLoadCtClass(clB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, clB);
}
finally
{
@@ -216,8 +216,8 @@
assertNoClassLoader(rB);
CtClass classA1 = assertLoadCtClass(CLASS_A, clA);
assertSame(classA, classA1);
- assertCannotLoadCtClass(clA, CLASS_B);
- assertCannotLoadCtClass(clA, CLASS_C);
+ assertCannotLoadCtClass(CLASS_B, clA);
+ assertCannotLoadCtClass(CLASS_C, clA);
}
finally
{
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReplaceReferencesTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReplaceReferencesTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithReplaceReferencesTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -85,11 +85,6 @@
{
return suite(ClassPoolWithReplaceReferencesTestCase.class);
}
-
- public static AbstractTestDelegate getDelegate(Class<?> clazz) throws Exception
- {
- return new AlwaysWritablePermissionCollectionTestPolicyPluginTestDelegate(clazz);
- }
public void testParentLoadedParentDelegation() throws Exception
{
@@ -97,7 +92,7 @@
ClassPool scopedPool = null;
try
{
- getSystem().setTranslator(TRANSLATOR);
+ system.setTranslator(TRANSLATOR);
globalPool = createClassPool("GLOBAL", true, JAR_PARENT);
scopedPool = createChildDomainParentFirstClassPool("SCOPED", "SCOPED", true, JAR_CHILD);
@@ -109,7 +104,7 @@
unregisterClassPool(globalPool);
unregisterClassPool(scopedPool);
unregisterDomain(scopedPool);
- getSystem().setTranslator(null);
+ system.setTranslator(null);
}
}
@@ -119,7 +114,7 @@
ClassPool scopedPool = null;
try
{
- getSystem().setTranslator(TRANSLATOR);
+ system.setTranslator(TRANSLATOR);
globalPool = createClassPool("GLOBAL", true, JAR_PARENT);
scopedPool = createChildDomainParentLastClassPool("SCOPED", "SCOPED", true, JAR_CHILD);
@@ -131,7 +126,7 @@
unregisterClassPool(globalPool);
unregisterClassPool(scopedPool);
unregisterDomain(scopedPool);
- getSystem().setTranslator(null);
+ system.setTranslator(null);
}
}
@@ -141,7 +136,7 @@
ClassPool scopedPool = null;
try
{
- getSystem().setTranslator(TRANSLATOR);
+ system.setTranslator(TRANSLATOR);
globalPool = createClassPool("GLOBAL", true, JAR_PARENT);
scopedPool = createChildDomainParentFirstClassPool("SCOPED", "SCOPED", true, JAR_CHILD);
@@ -152,7 +147,7 @@
unregisterClassPool(globalPool);
unregisterClassPool(scopedPool);
unregisterDomain(scopedPool);
- getSystem().setTranslator(null);
+ system.setTranslator(null);
}
}
@@ -162,7 +157,7 @@
ClassPool scopedPool = null;
try
{
- getSystem().setTranslator(TRANSLATOR);
+ system.setTranslator(TRANSLATOR);
globalPool = createClassPool("GLOBAL", true, JAR_PARENT);
scopedPool = createChildDomainParentLastClassPool("SCOPED", "SCOPED", true, JAR_CHILD);
@@ -173,7 +168,7 @@
unregisterClassPool(globalPool);
unregisterClassPool(scopedPool);
unregisterDomain(scopedPool);
- getSystem().setTranslator(null);
+ system.setTranslator(null);
}
}
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithRepositoryTestCase.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithRepositoryTestCase.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/ClassPoolWithRepositoryTestCase.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -90,7 +90,7 @@
CtClass aFromA = poolA.get(CLASS_A);
assertNotNull(aFromA);
- assertCannotLoadCtClass(poolA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, poolA);
}
finally
{
@@ -112,7 +112,7 @@
childDomain = getChildDomainForPool(poolC);
assertNotNull(childDomain);
- assertSame(getSystem().getDefaultDomain(), childDomain.getParent());
+ assertSame(system.getDefaultDomain(), childDomain.getParent());
CtClass aFromA = poolA.get(CLASS_A);
assertNotNull(aFromA);
@@ -131,8 +131,8 @@
assertSame(poolB, bFromB.getClassPool());
assertSame(poolC, cFromC.getClassPool());
- assertCannotLoadCtClass(poolA, CLASS_C);
- assertCannotLoadCtClass(poolB, CLASS_C);
+ assertCannotLoadCtClass(CLASS_C, poolA);
+ assertCannotLoadCtClass(CLASS_C, poolB);
checkCanLoadString(poolA, poolB);
checkCanLoadString(poolB, poolC);
@@ -159,18 +159,18 @@
domainA = getChildDomainForPool(poolA);
assertNotNull(domainA);
- assertSame(getSystem().getDefaultDomain(), domainA.getParent());
+ assertSame(system.getDefaultDomain(), domainA.getParent());
domainB = getChildDomainForPool(poolB);
assertNotNull(domainB);
- assertSame(getSystem().getDefaultDomain(), domainB.getParent());
+ assertSame(system.getDefaultDomain(), domainB.getParent());
assertNotSame(domainA, domainB);
CtClass clazzA = poolA.get(CLASS_A);
assertSame(poolA, clazzA.getClassPool());
CtClass clazzB = poolB.get(CLASS_B);
assertSame(poolB, clazzB.getClassPool());
- assertCannotLoadCtClass(poolA, CLASS_B);
- assertCannotLoadCtClass(poolB, CLASS_A);
+ assertCannotLoadCtClass(CLASS_B, poolA);
+ assertCannotLoadCtClass(CLASS_A, poolB);
checkCanLoadString(poolA, poolB);
}
@@ -190,7 +190,7 @@
try
{
scopedPool = createChildDomainParentFirstClassPool("SCOPED", "SCOPED", true, JAR_B_1);
- assertCannotLoadCtClass(scopedPool, CLASS_A);
+ assertCannotLoadCtClass(CLASS_A, scopedPool);
globalPool = createClassPool("GLOBAL", true, JAR_A_1);
@@ -293,7 +293,7 @@
try
{
poolA = createClassPool("A", true, JAR_A_1);
- assertCannotLoadCtClass(poolA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, poolA);
poolB = createClassPool("B", true, JAR_B_1);
CtClass bFromA = poolA.get(CLASS_B);
@@ -303,7 +303,7 @@
{
unregisterClassPool(poolB);
}
- assertCannotLoadCtClass(poolA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, poolA);
}
finally
{
@@ -322,10 +322,10 @@
try
{
globalA = createClassPool("A", true, JAR_A_1);
- assertCannotLoadCtClass(globalA, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, globalA);
child = createChildDomainParentLastClassPool("C", "C", true, JAR_C_1);
- assertCannotLoadCtClass(child, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, child);
globalB = createClassPool("B", true, JAR_B_1);
CtClass bFromChild = child.get(CLASS_B);
@@ -337,7 +337,7 @@
{
unregisterClassPool(globalB);
}
- assertCannotLoadCtClass(child, CLASS_B);
+ assertCannotLoadCtClass(CLASS_B, child);
}
finally
{
@@ -562,10 +562,10 @@
globalA = createClassPool("A", true, JAR_A_1);
globalB = createClassPool("B", true, JAR_B_1);
- assertCannotLoadClass(globalA.getClassLoader(), classnameA);
- assertCannotLoadClass(globalA.getClassLoader(), classnameB);
- assertCannotLoadClass(globalB.getClassLoader(), classnameA);
- assertCannotLoadClass(globalB.getClassLoader(), classnameB);
+ assertCannotLoadClass(classnameA, globalA.getClassLoader());
+ assertCannotLoadClass(classnameB, globalA.getClassLoader());
+ assertCannotLoadClass(classnameA, globalB.getClassLoader());
+ assertCannotLoadClass(classnameB, globalB.getClassLoader());
CtClass newCtClassA = globalA.makeClass(classnameA);
Class<?> newClassA = newCtClassA.toClass();
@@ -599,10 +599,10 @@
child1 = createChildDomainParentLastClassPool("C1", "C1", true, JAR_B_1);
child2 = createChildDomainParentLastClassPool("C2", "C2", "C1", true, JAR_C_1);
- assertCannotLoadCtClass(global, parentName);
- assertCannotLoadCtClass(child1, parentName);
- assertCannotLoadCtClass(child2, parentName);
- assertCannotLoadCtClass(child2, childName);
+ assertCannotLoadCtClass(parentName, global);
+ assertCannotLoadCtClass(parentName, child1);
+ assertCannotLoadCtClass(parentName, child2);
+ assertCannotLoadCtClass(childName, child2);
CtClass parentClass = global.makeClass(parentName);
@@ -617,8 +617,8 @@
assertSame(child2, childFromChild2.getClassPool());
assertSame(childClass, childFromChild2);
- assertCannotLoadCtClass(global, childName);
- assertCannotLoadCtClass(child1, childName);
+ assertCannotLoadCtClass(childName, global);
+ assertCannotLoadCtClass(childName, child1);
CtClass parentFromChildA = childClass.getSuperclass();
assertSame(parentClass, parentFromChildA);
@@ -665,12 +665,12 @@
child = createChildURLClassPool(globalA, JAR_C_1);
- assertCannotLoadCtClass(globalA, aClassName);
- assertCannotLoadCtClass(globalB, aClassName);
- assertCannotLoadCtClass(child, aClassName);
- assertCannotLoadCtClass(globalA, bClassName);
- assertCannotLoadCtClass(globalB, bClassName);
- assertCannotLoadCtClass(child, bClassName);
+ assertCannotLoadCtClass(aClassName, globalA);
+ assertCannotLoadCtClass(aClassName, globalB);
+ assertCannotLoadCtClass(aClassName, child);
+ assertCannotLoadCtClass(bClassName, globalA);
+ assertCannotLoadCtClass(bClassName, globalB);
+ assertCannotLoadCtClass(bClassName, child);
CtClass a = globalA.makeClass(aClassName);
CtClass b = globalB.makeClass(bClassName);
@@ -781,7 +781,7 @@
assertSame(parent, bFromGlobal.getClassPool());
CtClass bFromParent = parent.get(CLASS_B);
assertSame(bFromGlobal, bFromParent);
- assertCannotLoadCtClass(parent, CLASS_A);
+ assertCannotLoadCtClass(CLASS_A, parent);
}
finally
{
@@ -804,7 +804,7 @@
assertSame(parent, bFromGlobal.getClassPool());
CtClass bFromParent = parent.get(CLASS_B);
assertSame(bFromGlobal, bFromParent);
- assertCannotLoadCtClass(parent, CLASS_D);
+ assertCannotLoadCtClass(CLASS_D, parent);
CtMethod method = dFromGlobal.getDeclaredMethod("getB");
assertSame(method.getReturnType(), bFromParent);
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTest.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTest.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTest.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -1,24 +1,24 @@
/*
-* JBoss, Home of Professional Open Source.
-* Copyright 2006, Red Hat Middleware LLC, and individual contributors
-* as indicated by the @author tags. See the copyright.txt file in the
-* distribution for a full listing of individual contributors.
-*
-* This is free software; you can redistribute it and/or modify it
-* under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation; either version 2.1 of
-* the License, or (at your option) any later version.
-*
-* This software is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public
-* License along with this software; if not, write to the Free
-* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-*/
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2006, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
package org.jboss.test.classpool.jbosscl.test;
import java.net.MalformedURLException;
@@ -33,28 +33,19 @@
import javassist.ClassPool;
import javassist.CtClass;
+import javassist.NotFoundException;
import junit.framework.Test;
import org.jboss.aop.AspectManager;
import org.jboss.beans.metadata.spi.BeanMetaDataFactory;
-import org.jboss.classloader.plugins.filter.CombiningClassFilter;
-import org.jboss.classloader.plugins.filter.PatternClassFilter;
import org.jboss.classloader.spi.ClassLoaderDomain;
import org.jboss.classloader.spi.ClassLoaderSystem;
-import org.jboss.classloader.spi.ParentPolicy;
-import org.jboss.classloader.spi.filter.ClassFilter;
-import org.jboss.classloader.spi.filter.PackageClassFilter;
-import org.jboss.classloader.test.support.IsolatedClassLoaderTestHelper;
-import org.jboss.classloading.spi.dependency.ClassLoading;
import org.jboss.classloading.spi.dependency.Module;
-import org.jboss.classpool.plugins.as5.RegisterModuleCallback;
import org.jboss.classpool.plugins.as5.VFSClassLoaderDomainRegistry;
-import org.jboss.classpool.plugins.as5.jbosscl.JBossClDelegatingClassPoolFactory;
import org.jboss.classpool.spi.ClassPoolRepository;
import org.jboss.kernel.plugins.deployment.AbstractKernelDeployment;
import org.jboss.kernel.spi.deployment.KernelDeployment;
import org.jboss.test.AbstractTestCaseWithSetup;
-import org.jboss.test.AbstractTestDelegate;
import org.jboss.test.classpool.support.BundleInfoBuilder;
import org.jboss.test.classpool.support.Result;
import org.jboss.test.classpool.support.SupportClasses;
@@ -64,14 +55,16 @@
import org.jboss.virtual.VFS;
/**
- * Base class for testing the new JBoss classloaders
+ * Base class for testing the JBossClDelegatingClassPools.
*
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
+ * @author <a href="flavia.rainone at jboss.com">Flavia Rainone</a>
* @version $Revision$
*/
- at SuppressWarnings("all")
public class JBossClClassPoolTest extends MicrocontainerTest
{
+ /****** STATIC ***************************************************************************/
+
public final static URL JAR_A_1 = getURLRelativeToProjectRoot(SupportClasses.JAR_A_1);
public final static URL JAR_A_2 = getURLRelativeToProjectRoot(SupportClasses.JAR_A_2);
public final static URL JAR_B_1 = getURLRelativeToProjectRoot(SupportClasses.JAR_B_1);
@@ -79,94 +72,16 @@
public final static URL JAR_C_1 = getURLRelativeToProjectRoot(SupportClasses.JAR_C_1);
public final static URL JAR_C_2 = getURLRelativeToProjectRoot(SupportClasses.JAR_C_2);
public final static URL JAR_D = getURLRelativeToProjectRoot(SupportClasses.JAR_D);
-
- //Keep a strong reference to the URL classloaders so that they are not garbage collected
- final static Set<URLClassLoader> registeredURLClassLoaders = new HashSet<URLClassLoader>();
-
- private Map<ClassLoader, ClassLoaderDomain> scopedChildDomainsByLoader = new WeakHashMap<ClassLoader, ClassLoaderDomain>();
- private LoaderNameDeploymentRegistry loaderNameDeploymentRegistry = new LoaderNameDeploymentRegistry();
-
- /** The classloader helper */
- protected static final ClassLoaderSystem system = ClassLoaderSystem.getInstance();
- private static boolean initialisedDefaultDomain;
- private static final ClassFilter aopFilter;
- static
- {
- String[] classPatterns = new String[] {
- "org\\.jboss\\.aop\\..+",
- "org\\.jboss\\.classloading\\..+",
- "org\\.jboss\\.classloader\\..+",
- "org\\.jboss\\.virtual\\..+",
- "org\\.jboss\\.test\\.classpool\\.jbosscl\\..+\\..+",
- "org\\.jboss\\.metadata\\..+",
- "org\\.test\\.classpool\\.proxy\\..+"};
- String[] resourcePatterns = new String[] {
- "org/jboss/aop/.+",
- "org/jboss/classloading/.+",
- "org/jboss/classloader/.+",
- "org/jboss/virtual/.+",
- "org/jboss/test/classpool/jbosscl/.+\\..+",
- "org/jboss/metadata/.+",
- "org/test/classpool/proxy/.+"};
- aopFilter = new PatternClassFilter(classPatterns, resourcePatterns, null);
- }
-
- protected static VFSClassLoaderDomainRegistry domainRegistry;
-
- ClassLoading classLoading = new ClassLoading();
+ /** A strong reference to the URL classloaders so that they are not garbage collected */
+ private final static Set<URLClassLoader> registeredURLClassLoaders = new HashSet<URLClassLoader>();
-
- static
- {
-
- domainRegistry = new VFSClassLoaderDomainRegistry();
-
- // TODO remove this later; currently, AspectManager sets the classpoolfactory
- // at ScopedClassPoolRepositoryImpl, overwriting the setClassPoolFactory command below
- // Notice that AspectManager.instance() is invoked by AOPDependencyBuilder, so
- // we have no way of avoiding AspectManager creation
- AspectManager.instance();
- ClassPoolRepository.getInstance().setClassPoolFactory(new JBossClDelegatingClassPoolFactory(domainRegistry, new RegisterModuleCallback(domainRegistry)));
- VFS.init();
- }
-
-
- public static ClassLoaderSystem getSystem()
- {
- if (!initialisedDefaultDomain)
- {
- ClassLoaderDomain defaultDomain = system.getDefaultDomain();
-
- Set<String> parentPackages = IsolatedClassLoaderTestHelper.getParentPackages();
- String[] parentPkgs = parentPackages.toArray(new String[parentPackages.size()]);
- PackageClassFilter filter = new PackageClassFilter(parentPkgs);
- filter.setIncludeJava(true);
- CombiningClassFilter beforeFilter = CombiningClassFilter.create(filter, aopFilter);
- ParentPolicy parentPolicy = new ParentPolicy(beforeFilter, ClassFilter.NOTHING);
-
- defaultDomain.setParentPolicy(parentPolicy);
- }
- return system;
- }
-
public static Test suite(Class<?> clazz)
{
return AbstractTestCaseWithSetup.suite(clazz);
}
- public JBossClClassPoolTest(String name)
- {
- super(name);
- }
-
-
- public static AbstractTestDelegate getDelegate(Class<?> clazz) throws Exception
- {
- return new JBossClClassPoolTestDelegate(clazz);
- }
-
-
+ /** Returns the relative URL to the project root */
protected static URL getURLRelativeToProjectRoot(String relativePath)
{
try
@@ -181,26 +96,66 @@
}
catch (MalformedURLException e)
{
- // AutoGenerated
throw new RuntimeException(e);
}
}
- protected ClassLoaderDomain getDefaultDomain()
+ // FIXME
+ static
{
- return getSystem().getDefaultDomain();
+ // TODO remove this later; currently, AspectManager sets the classpoolfactory
+ // at ScopedClassPoolRepositoryImpl, overwriting the setClassPoolFactory command below
+ // Notice that AspectManager.instance() is invoked by AOPDependencyBuilder, so
+ // we have no way of avoiding AspectManager creation
+ AspectManager.instance();
}
+
+ /****** HELPER FIELDS ********************************************************************/
+
+ /** The ClassPool repository */
+ private ClassPoolRepository repository;
+
+ /** The classloader helper */
+ protected ClassLoaderSystem system;
+
+ /** The domain registry */
+ protected VFSClassLoaderDomainRegistry domainRegistry;
+
+ /**
+ * Contains the same domains contained in dmoainRegistry. The difference is that
+ * This map is cleaned up later than domainRegistry.
+ */
+ private Map<ClassLoader, ClassLoaderDomain> scopedChildDomainsByLoader = new WeakHashMap<ClassLoader, ClassLoaderDomain>();
+
+ /**
+ * Keeps track of KernelDeployments
+ */
+ private LoaderNameDeploymentRegistry loaderNameDeploymentRegistry = new LoaderNameDeploymentRegistry();
+
+ /****** CONSTRUCTOR **********************************************************************/
+
+ /**
+ * Constructor.
+ * @param name name of the test
+ */
+ public JBossClClassPoolTest(String name)
+ {
+ super(name);
+ }
+
+ /****** OVERRIDDEN METHODS ***************************************************************/
@Override
protected void setUp() throws Exception
{
super.setUp();
- //enableTrace("org.jboss.aop.classpool");
- //enableTrace("org.jboss.classpool.jbosscl");
deploy("/org/jboss/test/classpool/jbosscl/Common.xml");
+ VFS.init();
+ system = (ClassLoaderSystem) getBean("ClassLoaderSystem");
+ domainRegistry = (VFSClassLoaderDomainRegistry) getBean("ClassLoaderScopingPolicy");
+ repository = (ClassPoolRepository) getBean("ClassPoolRepository");
}
-
@Override
protected void tearDown() throws Exception
{
@@ -208,11 +163,8 @@
super.tearDown();
}
- protected String array(String name)
- {
- return name + "[]";
- }
-
+ /****** CREATE CLASSLOADER METHODS ***************************************************/
+
protected ClassLoader createClassLoader(String name, boolean importAll, URL... urls) throws Exception
{
return createClassLoader(null, name, importAll, urls);
@@ -224,27 +176,17 @@
return createClassLoader(result, factory);
}
- protected ClassLoader createClassLoader(String name, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createClassLoader(null, name, builder, urls);
- }
-
protected ClassLoader createClassLoader(Result result, String name, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createClassLoader(result, name, false, builder, urls);
}
-
- protected ClassLoader createClassLoader(String name, boolean importAll, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createClassLoader(null, name, importAll, builder, urls);
- }
-
+
protected ClassLoader createClassLoader(Result result, String name, boolean importAll, BundleInfoBuilder builder, URL... urls) throws Exception
{
TestVFSClassLoaderFactory factory = TestVFSClassLoaderFactoryFactory.createClassLoaderFactory(name, importAll, builder, urls);
return createClassLoader(result, factory);
}
-
+
protected ClassLoader createChildDomainParentFirstClassLoader(String name, String domainName, boolean importAll, URL... urls) throws Exception
{
return createChildDomainParentFirstClassLoader((Result)null, name, domainName, importAll, urls);
@@ -304,57 +246,22 @@
{
return createChildDomainClassLoader(result, name, domainName, parentDomainName, false, importAll, null, urls);
}
-
- protected ClassLoader createChildDomainClassLoader(String name, String domainName, String parentDomainName, boolean parentFirst, boolean importAll, ClassLoader parent, URL... urls) throws Exception
- {
- return createChildDomainClassLoader(null, name, domainName, parentDomainName, parentFirst, importAll, parent, urls);
- }
- protected ClassLoader createChildDomainClassLoader(Result result, String name, String domainName, String parentDomainName, boolean parentFirst, boolean importAll, ClassLoader parent, URL... urls) throws Exception
- {
- TestVFSClassLoaderFactory factory = TestVFSClassLoaderFactoryFactory.createClassLoaderFactory(name, importAll, domainName, parentDomainName, parentFirst, urls);
-
- ClassLoader classLoader = createClassLoader(result, factory, parent);
-
- registerDomainAndLoader(classLoader, domainName);
- return classLoader;
- }
-
- protected ClassLoader createChildDomainParentFirstClassLoader(String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentFirstClassLoader((Result)null, name, domainName, builder, urls);
- }
-
protected ClassLoader createChildDomainParentFirstClassLoader(Result result, String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createChildDomainParentFirstClassLoader(result, name, domainName, null, builder, urls);
}
- protected ClassLoader createChildDomainParentFirstClassLoader(String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentFirstClassLoader(null, name, domainName, parentDomainName, builder, urls);
- }
-
protected ClassLoader createChildDomainParentFirstClassLoader(Result result, String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createChildDomainClassLoader(result, name, domainName, parentDomainName, builder, true, urls);
}
-
- protected ClassLoader createChildDomainParentLastClassLoader(String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentLastClassLoader((Result)null, name, domainName, builder, urls);
- }
protected ClassLoader createChildDomainParentLastClassLoader(Result result, String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createChildDomainParentLastClassLoader(result, name, domainName, null, builder, urls);
}
- protected ClassLoader createChildDomainParentLastClassLoader(String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentLastClassLoader(null, name, domainName, parentDomainName, builder, urls);
- }
-
protected ClassLoader createChildDomainParentLastClassLoader(Result result, String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createChildDomainClassLoader(result, name, domainName, parentDomainName, builder, false, urls);
@@ -365,19 +272,25 @@
return createChildDomainClassLoader(null, name, domainName, parentDomainName, builder, parentFirst, urls);
}
- protected ClassLoader createChildDomainClassLoader(Result result, String name, String domainName, String parentDomainName, BundleInfoBuilder builder, boolean parentFirst, URL... urls) throws Exception
+ private ClassLoader createChildDomainClassLoader(Result result, String name, String domainName, String parentDomainName, boolean parentFirst, boolean importAll, ClassLoader parent, URL... urls) throws Exception
{
+ TestVFSClassLoaderFactory factory = TestVFSClassLoaderFactoryFactory.createClassLoaderFactory(name, importAll, domainName, parentDomainName, parentFirst, urls);
+ ClassLoader classLoader = createClassLoader(result, factory, parent);
+ registerDomainAndLoader(classLoader, domainName);
+ return classLoader;
+ }
+
+ private ClassLoader createChildDomainClassLoader(Result result, String name, String domainName, String parentDomainName, BundleInfoBuilder builder, boolean parentFirst, URL... urls) throws Exception
+ {
TestVFSClassLoaderFactory factory = TestVFSClassLoaderFactoryFactory.createClassLoaderFactory(name, domainName, parentDomainName, builder, parentFirst, urls);
-
ClassLoader classLoader = createClassLoader(result, factory);
-
registerDomainAndLoader(classLoader, domainName);
return classLoader;
}
-
+
private void registerDomainAndLoader(ClassLoader classLoader, String domainName)
{
- ClassLoaderDomain domain = getSystem().getDomain(domainName);
+ ClassLoaderDomain domain = system.getDomain(domainName);
scopedChildDomainsByLoader.put(classLoader, domain);
}
@@ -407,15 +320,28 @@
result.setFactory(factory);
}
ClassLoader loader = assertClassLoader(factory, parent);
-
return loader;
}
+
+ private KernelDeployment install(TestVFSClassLoaderFactory metaData) throws Exception
+ {
+ AbstractKernelDeployment deployment = new AbstractKernelDeployment();
+ deployment.setName(metaData.getName() + ":" + metaData.getVersion());
+ deployment.setBeanFactories(Collections.singletonList((BeanMetaDataFactory) metaData));
+ deploy(deployment);
+ return deployment;
+ }
+ /****** DOMAIN-RELATED METHODS *******************************************************/
+
/**
* Here since we cannot access this via the classloading api
*/
protected ClassLoaderDomain getChildDomainForLoader(ClassLoader loader)
{
+ //(scopedChildDomainsByLoader.get(loader) != domainRegistry.getClassLoaderDomainForLoader(loader))
+ // this statement is true only when the module has already been cleaned up from domainRegistry
+ // that's why we need another collection here
return scopedChildDomainsByLoader.get(loader);
}
@@ -423,87 +349,9 @@
{
return getChildDomainForLoader(pool.getClassLoader());
}
-
- protected void unregisterDomain(ClassLoaderDomain domain)
- {
- if (domain != null)
- {
- ClassLoaderDomain registeredDomain = getSystem().getDomain(domain.getName());
- if (registeredDomain == null)
- throw new IllegalStateException("Domain is not registered: " + domain.getName());
- if (registeredDomain != domain)
- throw new IllegalStateException(domain + " is not the same as " + registeredDomain);
- getSystem().unregisterDomain(domain);
- }
- }
-
- protected void unregisterDomain(ClassLoader loader)
- {
- if (loader != null)
- {
- ClassLoaderDomain domain = getChildDomainForLoader(loader);
- unregisterDomain(domain);
- }
- }
- protected void unregisterDomain(ClassPool pool)
- {
- if (pool != null)
- {
- ClassLoaderDomain domain = getChildDomainForPool(pool);
- unregisterDomain(domain);
- }
- }
-
- protected void assertCannotLoadClass(ClassLoader cl, String className)
- {
- try
- {
- cl.loadClass(className);
- fail("Should not have been able to load " + className);
- }
- catch(Exception expected)
- {
- }
- }
+ /****** CLASSPOOL METHODS ************************************************************/
- protected void assertCannotLoadClass(String className, ClassLoader cl)
- {
- assertCannotLoadClass(cl, className);
- }
-
- protected void assertCannotLoadCtClass(ClassPool pool, String className)
- {
- try
- {
- pool.get(className);
- }
- catch(Exception e)
- {
- }
- }
-
- protected void assertCannotLoadCtClass(String className, ClassPool pool)
- {
- assertCannotLoadCtClass(pool, className);
- }
-
- protected void assertCannotLoadClass(ClassLoaderDomain domain, String className)
- {
- try
- {
- Class<?> clazz = domain.loadClass(className);
- if (clazz == null)
- {
- return;
- }
- fail("Should not have been able to load " + className);
- }
- catch(Exception expected)
- {
- }
- }
-
protected ClassPool createClassPool(String name, boolean importAll, URL... urls) throws Exception
{
return createClassPool(null, name, importAll, urls);
@@ -515,11 +363,6 @@
return ClassPoolRepository.getInstance().registerClassLoader(loader);
}
- protected ClassPool createClassPool(String name, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createClassPool(null, name, builder, urls);
- }
-
protected ClassPool createClassPool(Result result, String name, BundleInfoBuilder builder, URL... urls) throws Exception
{
return createClassPool(result, name, false, builder, urls);
@@ -530,7 +373,7 @@
return createClassPool(null, name, importAll, builder, urls);
}
- protected ClassPool createClassPool(Result result, String name, boolean importAll, BundleInfoBuilder builder, URL... urls) throws Exception
+ private ClassPool createClassPool(Result result, String name, boolean importAll, BundleInfoBuilder builder, URL... urls) throws Exception
{
TestVFSClassLoaderFactory factory = TestVFSClassLoaderFactoryFactory.createClassLoaderFactory(name, importAll, builder, urls);
ClassLoader loader = createClassLoader(result, factory);
@@ -553,10 +396,10 @@
return createChildDomainParentFirstClassPool(null, name, domainName, importAll, parent, urls);
}
- protected ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, boolean importAll, ClassPool parent, URL... urls) throws Exception
+ private ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, boolean importAll, ClassPool parent, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentFirstClassLoader(result, name, domainName, importAll, parent.getClassLoader(), urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected ClassPool createChildDomainParentFirstClassPool(String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
@@ -564,10 +407,10 @@
return createChildDomainParentFirstClassPool(null, name, domainName, parentDomainName, importAll, urls);
}
- protected ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
+ private ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentFirstClassLoader(result, name, domainName, parentDomainName, importAll, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected ClassPool createChildDomainParentLastClassPool(String name, String domainName, boolean importAll, URL... urls) throws Exception
@@ -578,7 +421,7 @@
protected ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, boolean importAll, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentLastClassLoader(result, name, domainName, importAll, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected ClassPool createChildDomainParentLastClassPool(String name, String domainName, boolean importAll, ClassPool parent, URL... urls) throws Exception
@@ -586,10 +429,10 @@
return createChildDomainParentLastClassPool(null, name, domainName, importAll, parent, urls);
}
- protected ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, boolean importAll, ClassPool parent, URL... urls) throws Exception
+ private ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, boolean importAll, ClassPool parent, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentLastClassLoader(result, name, domainName, importAll, parent.getClassLoader(), urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected ClassPool createChildDomainParentLastClassPool(String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
@@ -597,43 +440,28 @@
return createChildDomainParentLastClassPool(null, name, domainName, parentDomainName, importAll, urls);
}
- protected ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
+ private ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, String parentDomainName, boolean importAll, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentLastClassLoader(result, name, domainName, parentDomainName, importAll, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
- protected ClassPool createChildDomainParentFirstClassPool(String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentFirstClassPool(null, name, domainName, parentDomainName, builder, urls);
- }
-
protected ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, String parentDomainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentFirstClassLoader(result, name, domainName, parentDomainName, builder, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
-
- protected ClassPool createChildDomainParentFirstClassPool(String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentFirstClassPool((Result)null, name, domainName, builder, urls);
- }
protected ClassPool createChildDomainParentFirstClassPool(Result result, String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentFirstClassLoader(result, name, domainName, builder, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
- protected ClassPool createChildDomainParentLastClassPool(String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
- {
- return createChildDomainParentLastClassPool(null, name, domainName, builder, urls);
- }
-
protected ClassPool createChildDomainParentLastClassPool(Result result, String name, String domainName, BundleInfoBuilder builder, URL... urls) throws Exception
{
ClassLoader loader = createChildDomainParentLastClassLoader(result, name, domainName, builder, urls);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected ClassPool createChildURLClassPool(ClassPool parent, URL url)
@@ -644,99 +472,94 @@
parentLoader = parent.getClassLoader();
}
ClassLoader loader = createChildURLClassLoader(parentLoader, url);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
- protected void registerModule(ClassLoader loader, Module module)
- {
- registerModule(loader, module, null);
- }
+ /****** REGISTER & UNREGISTER METHODS ************************************************/
- protected void registerModule(ClassLoader loader, Module module, ClassLoader parent)
+ /**
+ * This method does nothing but can be overriden by a subclass.
+ *
+ * @param module the module that has been created.
+ */
+ protected void registerModule(Module module)
{
- if (getSystem() != domainRegistry.getSystem())
- {
- domainRegistry.setSystem(getSystem());
- }
-
- //TODO I have just hacked the domain here so this might cause problems
- //with the tests if we try to do weaving. However, it should be fine while just testing pools
- //and loaders
- /*ScopedVFSClassLoaderDomainSetup setup = peekClassLoaderDomainSetup();
- ScopedVFSClassLoaderDomain domain = null;
- if (setup != null)
- {
- ClassLoaderDomain clDomain = getSystem().getDomain(module.getDomainName());
- setup.setClassLoaderAndDomain(loader, clDomain);
- domain = setup.getDomain();
- }*/
- domainRegistry.initMapsForLoader(loader, module, parent);
+ // do nothing, as this is already handled by ClassPool creation
+ // override this one only if you are not using ClassPools and need
+ // to have domainRegistry compliant with the modules/cls created
}
- protected void unregisterModule(ClassLoader loader)
+ /**
+ * Unregister a domain
+ *
+ * @param name the class loader domain
+ */
+ protected void unregisterDomain(ClassLoaderDomain domain)
{
- domainRegistry.cleanupLoader(loader);
- }
-
- protected void assertModule(ClassLoader loader)
- {
- ClassLoaderDomain domainForLoader = scopedChildDomainsByLoader.get(loader);
- if (domainForLoader == null)
+ if (domain != null)
{
- //domainForLoader = helper.getDomain();
- domainForLoader = getSystem().getDefaultDomain();
+ ClassLoaderDomain registeredDomain = system.getDomain(domain.getName());
+ if (registeredDomain == null)
+ throw new IllegalStateException("Domain is not registered: " + domain.getName());
+ if (registeredDomain != domain)
+ throw new IllegalStateException(domain + " is not the same as " + registeredDomain);
+ system.unregisterDomain(domain);
}
- assertNotNull(domainForLoader);
-
- ClassLoaderDomain domainForModule = domainRegistry.getClassLoaderDomainForLoader(loader);
- assertNotNull(domainForModule);
- assertSame(domainForLoader, domainForModule);
-
- Module module = domainRegistry.getModule(loader);
- assertNotNull(module);
- assertEquals(domainForModule.getName(), module.getDomainName());
- assertEquals(domainForModule.getParentDomainName(), module.getParentDomainName());
}
-
- protected void assertNoClassLoader(Result result) throws Exception
+ /**
+ * Unregister a domain
+ *
+ * @param name the class loader
+ */
+ protected void unregisterDomain(ClassLoader loader)
{
- if (result == null)
+ if (loader != null)
{
- throw new IllegalStateException("Null result");
+ ClassLoaderDomain domain = getChildDomainForLoader(loader);
+ unregisterDomain(domain);
}
- assertNoClassLoader(getContextName(result.getFactory()));
}
-
- protected void assertNoClassPool(Result result) throws Exception
+
+ /**
+ * Unregister a domain
+ *
+ * @param name the class pool
+ */
+ protected void unregisterDomain(ClassPool pool)
{
- if (result == null)
+ if (pool != null)
{
- throw new IllegalStateException("Null result");
+ ClassLoaderDomain domain = getChildDomainForPool(pool);
+ unregisterDomain(domain);
}
- assertNoClassLoader(getContextName(result.getFactory()));
}
- protected void assertNoClassLoader(String name) throws Exception
+ /**
+ * Unregister a domain
+ *
+ * @param name the domain name
+ */
+ protected void unregisterDomain(String name)
{
- try
+ if (name != null)
{
- Object bean = getBean(name, null);
- if (bean != null)
- fail("Should not be here: " + bean);
+ ClassLoaderDomain registeredDomain = system.getDomain(name);
+ unregisterDomain(registeredDomain);
}
- catch (Throwable t)
- {
- checkThrowable(IllegalStateException.class, t);
- }
}
- protected void unregisterClassPool(ClassPool pool) throws Exception
+ /**
+ * Unregister a clas pool
+ * @param pool the class pool
+ * @throws Exception
+ */
+ protected void unregisterClassPool(ClassPool pool)
{
if (pool != null)
{
ClassLoader loader = pool.getClassLoader();
- ClassPoolRepository.getInstance().unregisterClassLoader(loader);
+ repository.unregisterClassLoader(loader);
if (loader != null)
{
unregisterClassLoader(loader);
@@ -744,20 +567,31 @@
}
}
- protected void unregisterClassLoader(ClassLoader classLoader) throws Exception
+ /**
+ * Unregisters a class loader
+ *
+ * @param classLoader the classloader
+ * @throws Exception
+ */
+ protected void unregisterClassLoader(ClassLoader classLoader)
{
if (classLoader != null)
{
if (registeredURLClassLoaders.remove(classLoader) == false)
{
- domainRegistry.cleanupLoader(classLoader);
KernelDeployment deployment = loaderNameDeploymentRegistry.unregisterDeployment(classLoader);
unregisterDeployment(deployment);
}
}
}
- protected void unregisterClassLoader(String name) throws Exception
+ /**
+ * Unregisters a class loader.
+ *
+ * @param name the class loader name
+ * @throws Exception
+ */
+ protected void unregisterClassLoader(String name)
{
KernelDeployment deployment = loaderNameDeploymentRegistry.unregisterDeployment(name);
unregisterDeployment(deployment);
@@ -771,37 +605,27 @@
}
}
- /**
- * Unregister a domain
- *
- * @param name the domain name
- */
- protected void unregisterDomain(String name)
+ /****** ASSERT METHODS ***************************************************************/
+
+ protected void assertModule(ClassLoader loader)
{
- if (name != null)
+ ClassLoaderDomain domainForLoader = getChildDomainForLoader(loader);
+ if (domainForLoader == null)
{
- ClassLoaderDomain registeredDomain = getSystem().getDomain(name);
- unregisterDomain(registeredDomain);
+ domainForLoader = system.getDefaultDomain();
}
+ assertNotNull(domainForLoader);
+
+ ClassLoaderDomain domainForModule = domainRegistry.getClassLoaderDomainForLoader(loader);
+ assertNotNull(domainForModule);
+ assertSame(domainForLoader, domainForModule);
+
+ Module module = domainRegistry.getModule(loader);
+ assertNotNull(module);
+ assertEquals(domainForModule.getName(), module.getDomainName());
+ assertEquals(domainForModule.getParentDomainName(), module.getParentDomainName());
}
- protected KernelDeployment install(TestVFSClassLoaderFactory metaData) throws Exception
- {
- AbstractKernelDeployment deployment = new AbstractKernelDeployment();
- deployment.setName(metaData.getName() + ":" + metaData.getVersion());
- deployment.setBeanFactories(Collections.singletonList((BeanMetaDataFactory) metaData));
- deploy(deployment);
- return deployment;
- }
-
- protected String getContextName(TestVFSClassLoaderFactory factory)
- {
- String contextName = factory.getContextName();
- if (contextName == null)
- contextName = factory.getName() + ":" + factory.getVersion();
- return contextName;
- }
-
protected ClassLoader assertClassLoader(TestVFSClassLoaderFactory factory) throws Exception
{
return assertClassLoader(factory, null);
@@ -815,7 +639,7 @@
ClassLoader loader = assertInstanceOf(obj, ClassLoader.class);
Module module = assertModule(getContextName(factory));
- registerModule(loader, module, parent);
+ registerModule(module);
loaderNameDeploymentRegistry.registerLoaderName(factory.getName(), loader);
return loader;
@@ -826,10 +650,90 @@
}
}
+ protected void assertCannotLoadClass(String className, ClassLoader cl)
+ {
+ try
+ {
+ cl.loadClass(className);
+ fail("Should not have been able to load " + className);
+ }
+ catch(ClassNotFoundException expected)
+ {
+ }
+ }
+
+ protected void assertCannotLoadCtClass(String className, ClassPool pool)
+ {
+ try
+ {
+ pool.get(className);
+ }
+ catch(NotFoundException e)
+ {
+ }
+ }
+
+ protected void assertCannotLoadClass(String className, ClassLoaderDomain domain)
+ {
+ try
+ {
+ Class<?> clazz = domain.loadClass(className);
+ if (clazz == null)
+ {
+ return;
+ }
+ fail("Should not have been able to load " + className);
+ }
+ catch(Exception expected)
+ {
+ }
+ }
+
+ protected void assertNoClassLoader(Result result) throws Exception
+ {
+ if (result == null)
+ {
+ throw new IllegalStateException("Null result");
+ }
+ assertNoClassLoader(getContextName(result.getFactory()));
+ }
+
+ protected void assertNoClassPool(Result result) throws Exception
+ {
+ if (result == null)
+ {
+ throw new IllegalStateException("Null result");
+ }
+ assertNoClassLoader(getContextName(result.getFactory()));
+ }
+
+ protected void assertNoClassLoader(String name) throws Exception
+ {
+ try
+ {
+ Object bean = getBean(name, null);
+ if (bean != null)
+ fail("Should not be here: " + bean);
+ }
+ catch (Throwable t)
+ {
+ checkThrowable(IllegalStateException.class, t);
+ }
+ }
+
+ private String getContextName(TestVFSClassLoaderFactory factory)
+ {
+ String contextName = factory.getContextName();
+ if (contextName == null)
+ contextName = factory.getName() + ":" + factory.getVersion();
+ return contextName;
+ }
+
+
protected ClassPool assertClassPool(TestVFSClassLoaderFactory factory) throws Exception
{
ClassLoader loader = assertClassLoader(factory);
- return ClassPoolRepository.getInstance().registerClassLoader(loader);
+ return repository.registerClassLoader(loader);
}
protected Class<?> assertLoadClass(String name, ClassLoader initiating) throws Exception
@@ -883,7 +787,7 @@
String arrayName = name;
for (int i = 0 ; i < dimensions ; i++)
{
- arrayName = array(arrayName);
+ arrayName = arrayName + "[]";
}
CtClass array = initiating.get(arrayName);
@@ -907,16 +811,20 @@
return assertBean(contextName + "$MODULE", Module.class);
}
+ /****** TEST METHOD ******************************************************************/
+
/**
* The test classes should not be on the launcher classpath
*/
public void testClassesNotOnClasspath()
{
- assertCannotLoadClass(this.getClass().getClassLoader(), SupportClasses.CLASS_A);
- assertCannotLoadClass(this.getClass().getClassLoader(), SupportClasses.CLASS_B);
- assertCannotLoadClass(this.getClass().getClassLoader(), SupportClasses.CLASS_C);
+ assertCannotLoadClass(SupportClasses.CLASS_A, this.getClass().getClassLoader());
+ assertCannotLoadClass(SupportClasses.CLASS_B, this.getClass().getClassLoader());
+ assertCannotLoadClass(SupportClasses.CLASS_C, this.getClass().getClassLoader());
}
+ /****** AUXILIARY INTERNAL CLASS *****************************************************/
+
static class NoSuchClassLoaderException extends Exception
{
private static final long serialVersionUID = 1L;
@@ -960,54 +868,4 @@
return unregisterDeployment(name);
}
}
-
- /*private static ScopedVFSClassLoaderDomainSetup classLoaderDomainSetup;
-
- protected static void pushClassLoaderDomainSetup(ScopedVFSClassLoaderDomainSetup setup)
- {
- classLoaderDomainSetup = setup;
- }
-
- protected static ScopedVFSClassLoaderDomainSetup popClassLoaderDomainSetup()
- {
- ScopedVFSClassLoaderDomainSetup setup = classLoaderDomainSetup;
- classLoaderDomainSetup = null;
- return setup;
- }
-
- protected static ScopedVFSClassLoaderDomainSetup peekClassLoaderDomainSetup()
- {
- return classLoaderDomainSetup;
- }*/
-
- /*public class ScopedVFSClassLoaderDomainSetup
- {
- ScopedVFSClassLoaderDomain domain;
-
- String name;
- boolean parentDelegation;
- boolean parentFirst;
- DomainRegistry registry;
-
- public ScopedVFSClassLoaderDomainSetup(String name, boolean parentDelegation, boolean parentFirst, DomainRegistry registry)
- {
- this.name = name;
- this.parentDelegation = parentDelegation;
- this.parentFirst = parentFirst;
- this.registry = registry;
- }
-
- public ScopedVFSClassLoaderDomain getDomain()
- {
- return domain;
- }
-
- public void setClassLoaderAndDomain(ClassLoader loader, ClassLoaderDomain clDomain)
- {
- if (domain == null)
- {
- domain = new ScopedVFSClassLoaderDomain(loader, name, parentDelegation, parentFirst, clDomain, registry);
- }
- }
- }*/
}
Deleted: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTestDelegate.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTestDelegate.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/jbosscl/test/JBossClClassPoolTestDelegate.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -1,41 +0,0 @@
-/*
-* JBoss, Home of Professional Open Source.
-* Copyright 2006, Red Hat Middleware LLC, and individual contributors
-* as indicated by the @author tags. See the copyright.txt file in the
-* distribution for a full listing of individual contributors.
-*
-* This is free software; you can redistribute it and/or modify it
-* under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation; either version 2.1 of
-* the License, or (at your option) any later version.
-*
-* This software is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public
-* License along with this software; if not, write to the Free
-* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-*/
-package org.jboss.test.classpool.jbosscl.test;
-
-import org.jboss.test.kernel.junit.MicrocontainerTestDelegate;
-
-/**
- *
- * @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
- * @version $Revision$
- */
-public class JBossClClassPoolTestDelegate extends MicrocontainerTestDelegate
-{
-
- public JBossClClassPoolTestDelegate(Class<?> clazz) throws Exception
- {
- super(clazz);
-// String property = System.getProperty("jboss.aop.secure", "true");
-// boolean enableSecurity = Boolean.valueOf(property).booleanValue();
-// this.enableSecurity = enableSecurity;
- }
-}
Modified: projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/support/TestVFSClassLoaderFactoryFactory.java
===================================================================
--- projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/support/TestVFSClassLoaderFactoryFactory.java 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/java/org/jboss/test/classpool/support/TestVFSClassLoaderFactoryFactory.java 2009-11-20 19:54:00 UTC (rev 96653)
@@ -36,7 +36,7 @@
*/
public class TestVFSClassLoaderFactoryFactory
{
- public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, URL... urls) throws Exception
+ public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, URL... urls)
{
return createClassLoaderFactory(name, importAll, null, false, urls);
}
@@ -61,17 +61,17 @@
return createClassLoaderFactory(name, importAll, null, false, urls);
}
- public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, boolean parentFirst, URL... urls) throws Exception
+ public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, boolean parentFirst, URL... urls)
{
return createClassLoaderFactory(name, importAll, domainName, null, parentFirst, urls);
}
- public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, String parentDomainName, boolean parentFirst, URL... urls) throws Exception
+ public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, String parentDomainName, boolean parentFirst, URL... urls)
{
return createClassLoaderFactory(name, importAll, domainName, parentDomainName, null, parentFirst, urls);
}
- public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, String parentDomainName, BundleInfoBuilder builder, boolean parentFirst, URL... urls) throws Exception
+ public static TestVFSClassLoaderFactory createClassLoaderFactory(String name, boolean importAll, String domainName, String parentDomainName, BundleInfoBuilder builder, boolean parentFirst, URL... urls)
{
TestVFSClassLoaderFactory factory = new TestVFSClassLoaderFactory();
factory.setName(name);
Modified: projects/jboss-classpool/trunk/src/test/resources/org/jboss/test/classpool/jbosscl/Common.xml
===================================================================
--- projects/jboss-classpool/trunk/src/test/resources/org/jboss/test/classpool/jbosscl/Common.xml 2009-11-20 19:46:06 UTC (rev 96652)
+++ projects/jboss-classpool/trunk/src/test/resources/org/jboss/test/classpool/jbosscl/Common.xml 2009-11-20 19:54:00 UTC (rev 96653)
@@ -3,7 +3,7 @@
<deployment xmlns="urn:jboss:bean-deployer:2.0">
<bean name="ClassLoaderSystem" class="org.jboss.classloader.spi.ClassLoaderSystem">
- <constructor factoryClass="org.jboss.test.classpool.jbosscl.test.JBossClClassPoolTest" factoryMethod="getSystem"/>
+ <constructor factoryMethod="getInstance"/>
</bean>
<bean name="ClassLoading" class="org.jboss.classloading.spi.dependency.ClassLoading">
@@ -11,4 +11,32 @@
<uncallback method="removeModule" state="Configured"/>
</bean>
+ <bean name="ClassLoaderScopingPolicy" class="org.jboss.classpool.plugins.as5.VFSClassLoaderDomainRegistry">
+ <constructor factoryMethod="getInstance"/>
+ </bean>
+
+ <bean name="RegisterModuleCallback" class="org.jboss.classpool.plugins.as5.RegisterModuleCallback">
+ <constructor>
+ <parameter><inject bean="ClassLoaderScopingPolicy"/></parameter>
+ </constructor>
+ <install method="addModuleRegistry" bean="ClassLoading" whenRequired="Start">
+ <parameter><this/></parameter>
+ </install>
+ <uninstall method="removeModuleRegistry" bean="ClassLoading" whenRequired="Start">
+ <parameter><this/></parameter>
+ </uninstall>
+ </bean>
+
+ <bean name="ClassPoolFactory" class="org.jboss.classpool.plugins.as5.jbosscl.JBossClDelegatingClassPoolFactory">
+ <constructor>
+ <parameter><inject bean="ClassLoaderScopingPolicy"/></parameter>
+ <parameter><inject bean="RegisterModuleCallback"/></parameter>
+ </constructor>
+ </bean>
+
+ <bean name="ClassPoolRepository" class="org.jboss.classpool.plugins.as5.jbosscl.JBossClDelegatingClassPoolRepository">
+ <constructor factoryMethod="getInstance"/>
+ <property name="classPoolFactory"><inject bean="ClassPoolFactory"/></property>
+ </bean>
+
</deployment>
More information about the jboss-cvs-commits
mailing list