/*
* JBoss, Home of Professional Open Source.
* Copyright 2007, 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.classloader.jmx.test;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import junit.framework.Test;
import org.jboss.classloader.plugins.ClassLoaderUtils;
import org.jboss.classloader.plugins.jdk.AbstractJDKChecker;
import org.jboss.classloader.spi.ClassLoaderDomain;
import org.jboss.classloader.spi.ClassLoaderSystem;
import org.jboss.classloader.spi.ParentPolicy;
import org.jboss.classloader.test.support.MockClassLoaderPolicy;
import org.jboss.classloading.spi.RealClassLoader;
import org.jboss.test.classloader.AbstractClassLoaderTest;
import org.jboss.test.classloader.jmx.support.Simple;
import org.jboss.test.classloader.jmx.support.a.A;
import org.jboss.test.classloader.jmx.support.b.B;
/**
* JMXUnitTestCase
*
* @author <a href="adrian@jboss.com">Adrian Brock</a>
* @version $Revision: 1.1 $
*/
public class JMXUnitTestCase extends AbstractClassLoaderTest
{
private static final ObjectName CLASSLOADER_SYSTEM_OBJECT_NAME;
static
{
try
{
CLASSLOADER_SYSTEM_OBJECT_NAME = new ObjectName("test:type=ClassLoaderSystem");
}
catch (MalformedObjectNameException e)
{
throw new RuntimeException("Unexpected error", e);
}
AbstractJDKChecker.getExcluded().add(JMXUnitTestCase.class);
}
public static Test suite()
{
return suite(JMXUnitTestCase.class);
}
public JMXUnitTestCase(String name)
{
super(name);
}
public void testJMXClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MockClassLoaderPolicy policy = createMockClassLoaderPolicy("simple");
policy.setPathsAndPackageNames(Simple.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(policy);
MBeanServer server = MBeanServerFactory.newMBeanServer();
ObjectName clName = cl.getObjectName();
server.registerMBean(cl, clName);
getLog().debug("Registered classloader " + cl + " with name " + clName);
ObjectName name = new ObjectName("test:test=simple");
server.createMBean(Simple.class.getName(), name, clName);
MBeanInfo info = server.getMBeanInfo(name);
assertEquals(Simple.class.getName(), info.getClassName());
Object actual = server.getAttribute(name, "ClassLoader");
getLog().debug("Actual ClassLoader=" + actual + " expected " + cl);
assertEquals(cl, actual);
}
@SuppressWarnings("unchecked")
public void testClassLoaderSystemMBean() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
Set<String> domainNames = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "DomainNames");
Set<String> expected = makeSet(ClassLoaderSystem.DEFAULT_DOMAIN_NAME);
assertEquals(expected, domainNames);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ObjectName defaultDomainObjectName = defaultDomain.getObjectName();
Set<ObjectName> domains = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "Domains");
Set<ObjectName> expectedObjectNames = makeSet(defaultDomainObjectName);
assertEquals(expectedObjectNames, domains);
String domainName = (String) server.getAttribute(defaultDomainObjectName, "Name");
assertEquals(ClassLoaderSystem.DEFAULT_DOMAIN_NAME, domainName);
}
@SuppressWarnings("unchecked")
public void testRegisterDomain() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ObjectName defaultDomainObjectName = defaultDomain.getObjectName();
ClassLoaderDomain domain = system.createAndRegisterDomain("test");
ObjectName testObjectName = domain.getObjectName();
Set<String> domainNames = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "DomainNames");
Set<String> expected = makeSet("test", ClassLoaderSystem.DEFAULT_DOMAIN_NAME);
assertEquals(expected, domainNames);
Set<ObjectName> domains = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "Domains");
Set<ObjectName> expectedObjectNames = makeSet(defaultDomainObjectName, testObjectName);
assertEquals(expectedObjectNames, domains);
String domainName = (String) server.getAttribute(testObjectName, "Name");
assertEquals("test", domainName);
system.unregisterDomain(domain);
assertFalse(server.isRegistered(testObjectName));
domainNames = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "DomainNames");
expected = makeSet(ClassLoaderSystem.DEFAULT_DOMAIN_NAME);
assertEquals(expected, domainNames);
domains = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "Domains");
expectedObjectNames = makeSet(defaultDomainObjectName);
assertEquals(expectedObjectNames, domains);
}
@SuppressWarnings("unchecked")
public void testLazyRegisterDomain() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
ClassLoaderDomain test = system.createAndRegisterDomain("test");
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
Set<String> domainNames = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "DomainNames");
Set<String> expected = makeSet("test", ClassLoaderSystem.DEFAULT_DOMAIN_NAME);
assertEquals(expected, domainNames);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ObjectName defaultDomainObjectName = defaultDomain.getObjectName();
ObjectName testObjectName = test.getObjectName();
Set<ObjectName> domains = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "Domains");
Set<ObjectName> expectedObjectNames = makeSet(defaultDomainObjectName, testObjectName);
assertEquals(expectedObjectNames, domains);
}
@SuppressWarnings("unchecked")
public void testUnregisterClassLoaderSystemUnregistersDomains() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
ClassLoaderDomain test = system.createAndRegisterDomain("test");
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
Set<String> domainNames = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "DomainNames");
Set<String> expected = makeSet("test", ClassLoaderSystem.DEFAULT_DOMAIN_NAME);
assertEquals(expected, domainNames);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ObjectName defaultDomainObjectName = defaultDomain.getObjectName();
ObjectName testObjectName = test.getObjectName();
Set<ObjectName> domains = (Set) server.getAttribute(CLASSLOADER_SYSTEM_OBJECT_NAME, "Domains");
Set<ObjectName> expectedObjectNames = makeSet(defaultDomainObjectName, testObjectName);
assertEquals(expectedObjectNames, domains);
server.unregisterMBean(CLASSLOADER_SYSTEM_OBJECT_NAME);
assertFalse(server.isRegistered(CLASSLOADER_SYSTEM_OBJECT_NAME));
for (ObjectName domain : domains)
assertFalse(server.isRegistered(domain));
}
public void testClassLoaderDomainMBean() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ClassLoaderDomain domain = system.createAndRegisterDomain("test", ParentPolicy.AFTER_BUT_JAVA_BEFORE, defaultDomain);
ObjectName testObjectName = domain.getObjectName();
assertEquals(CLASSLOADER_SYSTEM_OBJECT_NAME, server.getAttribute(testObjectName, "System"));
assertEquals(domain.getName(), server.getAttribute(testObjectName, "Name"));
assertEquals(ParentPolicy.AFTER_BUT_JAVA_BEFORE.toString(), server.getAttribute(testObjectName, "ParentPolicyName"));
assertEquals(defaultDomain.getObjectName(), server.getAttribute(testObjectName, "ParentDomain"));
assertEquals(defaultDomain.getName(), server.getAttribute(testObjectName, "ParentDomainName"));
}
public void testRegisterClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain domain = system.createAndRegisterDomain("test");
MockClassLoaderPolicy policy = createMockClassLoaderPolicy("simple");
policy.setPathsAndPackageNames(Simple.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), policy);
assertTrue(server.isRegistered(cl.getObjectName()));
system.unregisterClassLoader((ClassLoader) cl);
assertFalse(server.isRegistered(cl.getObjectName()));
}
public void testLazyRegisterClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
ClassLoaderDomain domain = system.createAndRegisterDomain("test");
MockClassLoaderPolicy policy = createMockClassLoaderPolicy("simple");
policy.setPathsAndPackageNames(Simple.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), policy);
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
assertTrue(server.isRegistered(cl.getObjectName()));
}
public void testUnregisterClassLoaderSystemUnregistersClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain domain = system.createAndRegisterDomain("test");
MockClassLoaderPolicy policy = createMockClassLoaderPolicy("simple");
policy.setPathsAndPackageNames(Simple.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), policy);
assertTrue(server.isRegistered(cl.getObjectName()));
server.unregisterMBean(CLASSLOADER_SYSTEM_OBJECT_NAME);
assertFalse(server.isRegistered(cl.getObjectName()));
}
public void testUnregisterDomainUnregistersClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain domain = system.createAndRegisterDomain("test");
MockClassLoaderPolicy policy = createMockClassLoaderPolicy("simple");
policy.setPathsAndPackageNames(Simple.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), policy);
assertTrue(server.isRegistered(cl.getObjectName()));
system.unregisterDomain(domain);
assertFalse(server.isRegistered(cl.getObjectName()));
}
@SuppressWarnings("unchecked")
public void testClassLoaderDomainClassLoaders() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ClassLoaderDomain domain = system.createAndRegisterDomain("test", ParentPolicy.BEFORE_BUT_JAVA_ONLY, defaultDomain);
MockClassLoaderPolicy a1 = createMockClassLoaderPolicy("a1");
a1.setPathsAndPackageNames(A.class);
RealClassLoader clA1 = (RealClassLoader) system.registerClassLoaderPolicy(domain, a1);
MockClassLoaderPolicy a2 = createMockClassLoaderPolicy("a2");
a2.setPathsAndPackageNames(A.class);
RealClassLoader clA2 = (RealClassLoader) system.registerClassLoaderPolicy(domain, a2);
MockClassLoaderPolicy b1 = createMockClassLoaderPolicy("b1");
b1.setPathsAndPackageNames(B.class);
RealClassLoader clB1 = (RealClassLoader) system.registerClassLoaderPolicy(domain, b1);
MockClassLoaderPolicy b2 = createMockClassLoaderPolicy("b2");
b2.setPaths(B.class);
RealClassLoader clB2 = (RealClassLoader) system.registerClassLoaderPolicy(domain, b2);
ObjectName testDomain = domain.getObjectName();
List<ObjectName> classLoaders = (List) server.invoke(testDomain, "listClassLoaders", null, null);
List<ObjectName> expected = Arrays.asList(clA1.getObjectName(), clA2.getObjectName(), clB1.getObjectName(), clB2.getObjectName());
assertEquals(expected, classLoaders);
Map<String, List<ObjectName>> packageClassLoaders = (Map) server.invoke(testDomain, "listExportingClassLoaders", null, null);
Map<String, List<ObjectName>> expectedMap = new HashMap<String, List<ObjectName>>();
expectedMap.put(A.class.getPackage().getName(), Arrays.asList(clA1.getObjectName(), clA2.getObjectName()));
expectedMap.put(B.class.getPackage().getName(), Arrays.asList(clB1.getObjectName()));
assertEquals(expectedMap, packageClassLoaders);
classLoaders = (List) server.invoke(testDomain, "listExportingClassLoaders", new Object[] { A.class.getPackage().getName() }, new String[] { String.class.getName()});
expected = Arrays.asList(clA1.getObjectName(), clA2.getObjectName());
classLoaders = (List) server.invoke(testDomain, "listExportingClassLoaders", new Object[] { B.class.getPackage().getName() }, new String[] { String.class.getName()});
expected = Arrays.asList(clB1.getObjectName());
Class<?> clazz = (Class<?>) server.invoke(testDomain, "loadClass", new Object[] { A.class.getName() }, new String[] { String.class.getName() });
assertEquals(((ClassLoader) clA1).loadClass(A.class.getName()), clazz);
ObjectName result = (ObjectName) server.invoke(testDomain, "findClassLoaderForClass", new Object[] { A.class.getName() }, new String[] { String.class.getName() });
assertEquals(clA1.getObjectName(), result);
assertNull(server.invoke(testDomain, "findClassLoaderForClass", new Object[] { Object.class.getName() }, new String[] { String.class.getName() }));
String resourceName = ClassLoaderUtils.classNameToPath(A.class.getName());
Set<URL> urls = (Set) server.invoke(testDomain, "loadResources", new Object[] { resourceName }, new String[] { String.class.getName()});
Set<URL> expectedURLs = makeSet(getClass().getClassLoader().getResource(resourceName));
assertEquals(expectedURLs, urls);
}
@SuppressWarnings("unchecked")
public void testClassLoaderMBean() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
ClassLoaderDomain defaultDomain = system.getDefaultDomain();
ClassLoaderDomain domain = system.createAndRegisterDomain("test", ParentPolicy.BEFORE_BUT_JAVA_ONLY, defaultDomain);
MockClassLoaderPolicy a = createMockClassLoaderPolicy("a");
a.setPathsAndPackageNames(A.class);
RealClassLoader clA = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), a);
MockClassLoaderPolicy b = createMockClassLoaderPolicy("b");
b.setPathsAndPackageNames(B.class);
RealClassLoader clB = (RealClassLoader) system.registerClassLoaderPolicy(domain.getName(), b);
MockClassLoaderPolicy test = createMockClassLoaderPolicy("test");
test.setImportAll(true);
test.setDelegates(Arrays.asList(a.getExported(), b.getExported()));
test.setPathsAndPackageNames(A.class, B.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(domain, test);
ObjectName testObjectName = cl.getObjectName();
assertEquals(domain.getObjectName(), server.getAttribute(testObjectName, "ClassLoaderDomain"));
assertEquals("test", server.getAttribute(testObjectName, "Name"));
assertTrue((Boolean) server.getAttribute(testObjectName, "ImportAll"));
assertTrue((Boolean) server.getAttribute(testObjectName, "Valid"));
Set<String> expectedPackages = makeSet(A.class.getPackage().getName(), B.class.getPackage().getName());
assertEquals(expectedPackages, server.invoke(testObjectName, "listExportedPackages", null, null));
List<ObjectName> expectedImports = Arrays.asList(clA.getObjectName(), clB.getObjectName());
assertEquals(expectedImports, server.invoke(testObjectName, "listImports", null, null));
assertEquals(test.toLongString(), server.invoke(testObjectName, "listPolicyDetails", null, null));
}
@SuppressWarnings("unchecked")
public void testClassLoader() throws Exception
{
ClassLoaderSystem system = createClassLoaderSystemWithModifiedBootstrap();
MBeanServer server = MBeanServerFactory.newMBeanServer();
server.registerMBean(system, CLASSLOADER_SYSTEM_OBJECT_NAME);
system.getDefaultDomain().setParentPolicy(ParentPolicy.BEFORE_BUT_JAVA_ONLY);
MockClassLoaderPolicy test = createMockClassLoaderPolicy("test");
test.setPathsAndPackageNames(A.class, B.class);
RealClassLoader cl = (RealClassLoader) system.registerClassLoaderPolicy(test);
ObjectName testObjectName = cl.getObjectName();
Set<String> loadedClasses = (Set) server.invoke(testObjectName, "listLoadedClasses", null, null);
assertFalse(loadedClasses.contains(A.class.getName()));
Class<?> expected = ((ClassLoader) cl).loadClass(A.class.getName());
assertEquals(expected, server.invoke(testObjectName, "loadClass", new Object[] { A.class.getName() }, new String[] { String.class.getName() }));
loadedClasses = (Set) server.invoke(testObjectName, "listLoadedClasses", null, null);
assertTrue(loadedClasses.contains(A.class.getName()));
assertEquals(cl.getObjectName(), server.invoke(testObjectName, "findClassLoaderForClass", new Object[] { A.class.getName() }, new String[] { String.class.getName() }));
assertNull(server.invoke(testObjectName, "findClassLoaderForClass", new Object[] { Object.class.getName() }, new String[] { String.class.getName() }));
String resourceName = ClassLoaderUtils.classNameToPath(B.class.getName());
Set<String> loadedResourceNames = (Set) server.invoke(testObjectName, "listLoadedResourceNames", null, null);
assertFalse(loadedResourceNames.contains(resourceName));
Set<URL> expectedURLs = makeSet(((ClassLoader) cl).getResource(resourceName));
assertEquals(expectedURLs, server.invoke(testObjectName, "loadResources", new Object[] { resourceName }, new String[] { String.class.getName() }));
loadedResourceNames = (Set) server.invoke(testObjectName, "listLoadedResourceNames", null, null);
assertTrue(loadedResourceNames.contains(resourceName));
}
protected static <T> Set<T> makeSet(T... values)
{
Set<T> result = new HashSet<T>();
Collections.addAll(result, values);
return result;
}
}