()
{
public int compare( String g1,
String g2 )
{
return g1.compareTo( g2 );
}
};
Collections.sort( sortRealmNames, comparator );
// So now we have something like the following for defined
// realms:
//
// root
// root.maven
// root.maven.plugin
//
// Now if the name of a realm is a superset of an existing realm
// the we want to make child/parent associations.
for ( String realmName : sortRealmNames )
{
int j = realmName.lastIndexOf( '.' );
if ( j > 0 )
{
String parentRealmName = realmName.substring( 0, j );
ClassRealm parentRealm = configuredRealms.get( parentRealmName );
if ( parentRealm != null )
{
ClassRealm realm = configuredRealms.get( realmName );
realm.setParentRealm( parentRealm );
}
}
}
}
public void addImportFrom( String relamName, String importSpec )
throws NoSuchRealmException
{
curRealm.importFrom( relamName, importSpec );
}
public void addLoadFile( File file )
{
try
{
curRealm.addURL( file.toURI().toURL() );
}
catch ( MalformedURLException e )
{
// can't really happen... or can it?
}
}
public void addLoadURL( URL url )
{
curRealm.addURL( url );
}
public void addRealm( String realmName )
throws DuplicateRealmException
{
curRealm = world.newRealm( realmName, foreignClassLoader );
// Stash the configured realm for subsequent association processing.
configuredRealms.put( realmName, curRealm );
}
public void setAppMain( String mainClassName, String mainRealmName )
{
if ( this.launcher != null )
{
this.launcher.setAppMain( mainClassName, mainRealmName );
}
}
}
Launcher.java 0000664 0000000 0000000 00000033731 12203204422 0036273 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/launcher package org.codehaus.plexus.classworlds.launcher;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
import org.codehaus.plexus.classworlds.realm.NoSuchRealmException;
/**
* Command-line invokable application launcher.
*
*
* This launcher class assists in the creation of classloaders and ClassRealms
* from a configuration file and the launching of the application's main
* method from the correct class loaded through the correct classloader.
*
*
*
* The path to the configuration file is specified using the classworlds.conf
* system property, typically specified using the -D switch to
* java.
*
*
* @author bob mcwhirter
*/
public class Launcher
{
protected static final String CLASSWORLDS_CONF = "classworlds.conf";
protected static final String UBERJAR_CONF_DIR = "WORLDS-INF/conf/";
protected ClassLoader systemClassLoader;
protected String mainClassName;
protected String mainRealmName;
protected ClassWorld world;
private int exitCode = 0;
public Launcher()
{
this.systemClassLoader = Thread.currentThread().getContextClassLoader();
}
public void setSystemClassLoader( ClassLoader loader )
{
this.systemClassLoader = loader;
}
public ClassLoader getSystemClassLoader()
{
return this.systemClassLoader;
}
public int getExitCode()
{
return exitCode;
}
public void setAppMain( String mainClassName,
String mainRealmName )
{
this.mainClassName = mainClassName;
this.mainRealmName = mainRealmName;
}
public String getMainRealmName()
{
return this.mainRealmName;
}
public String getMainClassName()
{
return this.mainClassName;
}
public void setWorld( ClassWorld world )
{
this.world = world;
}
public ClassWorld getWorld()
{
return this.world;
}
/**
* Configure from a file.
*
* @param is The config input stream.
* @throws IOException If an error occurs reading the config file.
* @throws MalformedURLException If the config file contains invalid URLs.
* @throws ConfigurationException If the config file is corrupt.
* @throws org.codehaus.plexus.classworlds.realm.DuplicateRealmException If the config file defines two realms
* with the same id.
* @throws org.codehaus.plexus.classworlds.realm.NoSuchRealmException If the config file defines a main entry
* point in a non-existent realm.
*/
public void configure( InputStream is )
throws IOException, ConfigurationException, DuplicateRealmException, NoSuchRealmException
{
Configurator configurator = new Configurator( this );
configurator.configure( is );
}
/**
* Retrieve the main entry class.
*
* @return The main entry class.
* @throws ClassNotFoundException If the class cannot be found.
* @throws NoSuchRealmException If the specified main entry realm does not exist.
*/
public Class getMainClass()
throws ClassNotFoundException, NoSuchRealmException
{
return getMainRealm().loadClass( getMainClassName() );
}
/**
* Retrieve the main entry realm.
*
* @return The main entry realm.
* @throws NoSuchRealmException If the specified main entry realm does not exist.
*/
public ClassRealm getMainRealm()
throws NoSuchRealmException
{
return getWorld().getRealm( getMainRealmName() );
}
/**
* Retrieve the enhanced main entry method.
*
* @return The enhanced main entry method.
* @throws ClassNotFoundException If the main entry class cannot be found.
* @throws NoSuchMethodException If the main entry method cannot be found.
* @throws NoSuchRealmException If the main entry realm cannot be found.
*/
protected Method getEnhancedMainMethod()
throws ClassNotFoundException, NoSuchMethodException, NoSuchRealmException
{
Class cwClass = getMainRealm().loadClass( ClassWorld.class.getName() );
Method m = getMainClass().getMethod( "main", new Class[]{String[].class, cwClass} );
int modifiers = m.getModifiers();
if ( Modifier.isStatic( modifiers ) && Modifier.isPublic( modifiers ) )
{
if ( m.getReturnType() == Integer.TYPE || m.getReturnType() == Void.TYPE )
{
return m;
}
}
throw new NoSuchMethodException( "public static void main(String[] args, ClassWorld world)" );
}
/**
* Retrieve the main entry method.
*
* @return The main entry method.
* @throws ClassNotFoundException If the main entry class cannot be found.
* @throws NoSuchMethodException If the main entry method cannot be found.
* @throws NoSuchRealmException If the main entry realm cannot be found.
*/
protected Method getMainMethod()
throws ClassNotFoundException, NoSuchMethodException, NoSuchRealmException
{
Method m = getMainClass().getMethod( "main", new Class[]{String[].class} );
int modifiers = m.getModifiers();
if ( Modifier.isStatic( modifiers ) && Modifier.isPublic( modifiers ) )
{
if ( m.getReturnType() == Integer.TYPE || m.getReturnType() == Void.TYPE )
{
return m;
}
}
throw new NoSuchMethodException( "public static void main(String[] args) in " + getMainClass() );
}
/**
* Launch the application.
*
* @param args The application args.
* @throws ClassNotFoundException If the main entry class cannot be found.
* @throws IllegalAccessException If the method cannot be accessed.
* @throws InvocationTargetException If the target of the invokation is invalid.
* @throws NoSuchMethodException If the main entry method cannot be found.
* @throws NoSuchRealmException If the main entry realm cannot be found.
*/
public void launch( String[] args )
throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, NoSuchMethodException,
NoSuchRealmException
{
try
{
launchEnhanced( args );
return;
}
catch ( NoSuchMethodException e )
{
// ignore
}
launchStandard( args );
}
/**
* Attempt to launch the application through the enhanced main method.
*
*
* This will seek a method with the exact signature of:
*
*
*
* public static void main(String[] args, ClassWorld world)
*
*
* @param args The application args.
* @throws ClassNotFoundException If the main entry class cannot be found.
* @throws IllegalAccessException If the method cannot be accessed.
* @throws InvocationTargetException If the target of the invokation is
* invalid.
* @throws NoSuchMethodException If the main entry method cannot be found.
* @throws NoSuchRealmException If the main entry realm cannot be found.
*/
protected void launchEnhanced( String[] args )
throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, NoSuchMethodException,
NoSuchRealmException
{
ClassRealm mainRealm = getMainRealm();
Class mainClass = getMainClass();
Method mainMethod = getEnhancedMainMethod();
ClassLoader cl = mainRealm;
// ----------------------------------------------------------------------
// This is what the classloader for the main realm looks like when we
// boot from the command line:
// ----------------------------------------------------------------------
// [ AppLauncher$AppClassLoader ] : $CLASSPATH envar
// ^
// |
// |
// [ AppLauncher$ExtClassLoader ] : ${java.home}/jre/lib/ext/*.jar
// ^
// |
// |
// [ Strategy ]
// ----------------------------------------------------------------------
Thread.currentThread().setContextClassLoader( cl );
Object ret = mainMethod.invoke( mainClass, new Object[]{args, getWorld()} );
if ( ret instanceof Integer )
{
exitCode = ( (Integer) ret ).intValue();
}
Thread.currentThread().setContextClassLoader( systemClassLoader );
}
/**
* Attempt to launch the application through the standard main method.
*
*
* This will seek a method with the exact signature of:
*
*
*
* public static void main(String[] args)
*
*
* @param args The application args.
* @throws ClassNotFoundException If the main entry class cannot be found.
* @throws IllegalAccessException If the method cannot be accessed.
* @throws InvocationTargetException If the target of the invokation is
* invalid.
* @throws NoSuchMethodException If the main entry method cannot be found.
* @throws NoSuchRealmException If the main entry realm cannot be found.
*/
protected void launchStandard( String[] args )
throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, NoSuchMethodException,
NoSuchRealmException
{
ClassRealm mainRealm = getMainRealm();
Class mainClass = getMainClass();
Method mainMethod = getMainMethod();
Thread.currentThread().setContextClassLoader( mainRealm );
Object ret = mainMethod.invoke( mainClass, new Object[]{args} );
if ( ret instanceof Integer )
{
exitCode = ( (Integer) ret ).intValue();
}
Thread.currentThread().setContextClassLoader( systemClassLoader );
}
// ------------------------------------------------------------
// Class methods
// ------------------------------------------------------------
/**
* Launch the launcher from the command line.
* Will exit using System.exit with an exit code of 0 for success, 100 if there was an unknown exception,
* or some other code for an application error.
*
* @param args The application command-line arguments.
*/
public static void main( String[] args )
{
try
{
int exitCode = mainWithExitCode( args );
System.exit( exitCode );
}
catch ( Exception e )
{
e.printStackTrace();
System.exit( 100 );
}
}
/**
* Launch the launcher.
*
* @param args The application command-line arguments.
* @return an integer exit code
* @throws Exception If an error occurs.
*/
public static int mainWithExitCode( String[] args )
throws Exception
{
String classworldsConf = System.getProperty( CLASSWORLDS_CONF );
InputStream is;
Launcher launcher = new Launcher();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
launcher.setSystemClassLoader( cl );
if ( classworldsConf != null )
{
is = new FileInputStream( classworldsConf );
}
else
{
if ( "true".equals( System.getProperty( "classworlds.bootstrapped" ) ) )
{
is = cl.getResourceAsStream( UBERJAR_CONF_DIR + CLASSWORLDS_CONF );
}
else
{
is = cl.getResourceAsStream( CLASSWORLDS_CONF );
}
}
if ( is == null )
{
throw new Exception( "classworlds configuration not specified nor found in the classpath" );
}
launcher.configure( is );
is.close();
try
{
launcher.launch( args );
}
catch ( InvocationTargetException e )
{
ClassRealm realm = launcher.getWorld().getRealm( launcher.getMainRealmName() );
URL[] constituents = realm.getURLs();
System.out.println( "---------------------------------------------------" );
for ( int i = 0; i < constituents.length; i++ )
{
System.out.println( "constituent[" + i + "]: " + constituents[i] );
}
System.out.println( "---------------------------------------------------" );
// Decode ITE (if we can)
Throwable t = e.getTargetException();
if ( t instanceof Exception )
{
throw (Exception) t;
}
if ( t instanceof Error )
{
throw (Error) t;
}
// Else just toss the ITE
throw e;
}
return launcher.getExitCode();
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/realm/ 0000775 0000000 0000000 00000000000 12203204422 0033236 5 ustar 00root root 0000000 0000000 ClassRealm.java 0000664 0000000 0000000 00000034204 12203204422 0036053 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.strategy.Strategy;
import org.codehaus.plexus.classworlds.strategy.StrategyFactory;
import java.io.Closeable;
import java.io.IOException;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* The class loading gateway. Each class realm has access to a base class loader, imports form zero or more other class
* loaders, an optional parent class loader and of course its own class path. When queried for a class/resource, a class
* realm will always query its base class loader first before it delegates to a pluggable strategy. The strategy in turn
* controls the order in which imported class loaders, the parent class loader and the realm itself are searched. The
* base class loader is assumed to be capable of loading of the bootstrap classes.
*
* @author bob mcwhirter
* @author Jason van Zyl
*/
public class ClassRealm
extends URLClassLoader
{
private ClassWorld world;
private String id;
private SortedSet foreignImports;
private SortedSet parentImports;
private Strategy strategy;
private ClassLoader parentClassLoader;
private static final boolean isParallelCapable = Closeable.class.isAssignableFrom( URLClassLoader.class );
/**
* Creates a new class realm.
*
* @param world The class world this realm belongs to, must not be null.
* @param id The identifier for this realm, must not be null.
* @param baseClassLoader The base class loader for this realm, may be null to use the bootstrap class
* loader.
*/
public ClassRealm( ClassWorld world, String id, ClassLoader baseClassLoader )
{
super( new URL[0], baseClassLoader );
this.world = world;
this.id = id;
foreignImports = new TreeSet();
strategy = StrategyFactory.getStrategy( this );
}
public String getId()
{
return this.id;
}
public ClassWorld getWorld()
{
return this.world;
}
public void importFromParent( String packageName )
{
if ( parentImports == null )
{
parentImports = new TreeSet();
}
parentImports.add( new Entry( null, packageName ) );
}
boolean isImportedFromParent( String name )
{
if ( parentImports != null && !parentImports.isEmpty() )
{
for ( Entry entry : parentImports )
{
if ( entry.matches( name ) )
{
return true;
}
}
return false;
}
return true;
}
public void importFrom( String realmId, String packageName )
throws NoSuchRealmException
{
importFrom( getWorld().getRealm( realmId ), packageName );
}
public void importFrom( ClassLoader classLoader, String packageName )
{
foreignImports.add( new Entry( classLoader, packageName ) );
}
public ClassLoader getImportClassLoader( String name )
{
for ( Entry entry : foreignImports )
{
if ( entry.matches( name ) )
{
return entry.getClassLoader();
}
}
return null;
}
public Collection getImportRealms()
{
Collection importRealms = new HashSet();
for ( Entry entry : foreignImports )
{
if ( entry.getClassLoader() instanceof ClassRealm )
{
importRealms.add( (ClassRealm) entry.getClassLoader() );
}
}
return importRealms;
}
public Strategy getStrategy()
{
return strategy;
}
public void setParentClassLoader( ClassLoader parentClassLoader )
{
this.parentClassLoader = parentClassLoader;
}
public ClassLoader getParentClassLoader()
{
return parentClassLoader;
}
public void setParentRealm( ClassRealm realm )
{
this.parentClassLoader = realm;
}
public ClassRealm getParentRealm()
{
return ( parentClassLoader instanceof ClassRealm ) ? (ClassRealm) parentClassLoader : null;
}
public ClassRealm createChildRealm( String id )
throws DuplicateRealmException
{
ClassRealm childRealm = getWorld().newRealm( id, null );
childRealm.setParentRealm( this );
return childRealm;
}
public void addURL( URL url )
{
String urlStr = url.toExternalForm();
if ( urlStr.startsWith( "jar:" ) && urlStr.endsWith( "!/" ) )
{
urlStr = urlStr.substring( 4, urlStr.length() - 2 );
try
{
url = new URL( urlStr );
}
catch ( MalformedURLException e )
{
e.printStackTrace();
}
}
super.addURL( url );
}
// ----------------------------------------------------------------------
// We delegate to the Strategy here so that we can change the behavior
// of any existing ClassRealm.
// ----------------------------------------------------------------------
public Class loadClass( String name )
throws ClassNotFoundException
{
return loadClass( name, false );
}
protected Class loadClass( String name, boolean resolve )
throws ClassNotFoundException
{
if ( isParallelCapable )
{
return unsynchronizedLoadClass( name, resolve );
}
else
{
synchronized ( this )
{
return unsynchronizedLoadClass( name, resolve );
}
}
}
private Class unsynchronizedLoadClass( String name, boolean resolve )
throws ClassNotFoundException
{
try
{
// first, try loading bootstrap classes
return super.loadClass( name, resolve );
}
catch ( ClassNotFoundException e )
{
// next, try loading via imports, self and parent as controlled by strategy
return strategy.loadClass( name );
}
}
protected Class findClass( String name )
throws ClassNotFoundException
{
/*
* NOTE: This gets only called from ClassLoader.loadClass(Class, boolean) while we try to check for bootstrap
* stuff. Don't scan our class path yet, loadClassFromSelf() will do this later when called by the strategy.
*/
throw new ClassNotFoundException( name );
}
public URL getResource( String name )
{
URL resource = super.getResource( name );
return resource != null ? resource : strategy.getResource( name );
}
public URL findResource( String name )
{
return super.findResource( name );
}
public Enumeration getResources( String name )
throws IOException
{
Collection resources = new LinkedHashSet( Collections.list( super.getResources( name ) ) );
resources.addAll( Collections.list( strategy.getResources( name ) ) );
return Collections.enumeration( resources );
}
public Enumeration findResources( String name )
throws IOException
{
return super.findResources( name );
}
// ----------------------------------------------------------------------------
// Display methods
// ----------------------------------------------------------------------------
public void display()
{
display( System.out );
}
public void display( PrintStream out )
{
out.println( "-----------------------------------------------------" );
for ( ClassRealm cr = this; cr != null; cr = cr.getParentRealm() )
{
out.println( "realm = " + cr.getId() );
out.println( "strategy = " + cr.getStrategy().getClass().getName() );
showUrls( cr, out );
out.println();
}
out.println( "-----------------------------------------------------" );
}
private static void showUrls( ClassRealm classRealm, PrintStream out )
{
URL[] urls = classRealm.getURLs();
for ( int i = 0; i < urls.length; i++ )
{
out.println( "urls[" + i + "] = " + urls[i] );
}
out.println( "Number of foreign imports: " + classRealm.foreignImports.size() );
for ( Entry entry : classRealm.foreignImports )
{
out.println( "import: " + entry );
}
if ( classRealm.parentImports != null )
{
out.println( "Number of parent imports: " + classRealm.parentImports.size() );
for ( Entry entry : classRealm.parentImports )
{
out.println( "import: " + entry );
}
}
}
public String toString()
{
return "ClassRealm[" + getId() + ", parent: " + getParentClassLoader() + "]";
}
//---------------------------------------------------------------------------------------------
// Search methods that can be ordered by strategies to load a class
//---------------------------------------------------------------------------------------------
public Class loadClassFromImport( String name )
{
ClassLoader importClassLoader = getImportClassLoader( name );
if ( importClassLoader != null )
{
try
{
return importClassLoader.loadClass( name );
}
catch ( ClassNotFoundException e )
{
return null;
}
}
return null;
}
public Class loadClassFromSelf( String name )
{
synchronized ( getClassRealmLoadingLock( name ) )
{
try
{
Class clazz = findLoadedClass( name );
if ( clazz == null )
{
clazz = super.findClass( name );
}
return clazz;
}
catch ( ClassNotFoundException e )
{
return null;
}
}
}
private Object getClassRealmLoadingLock( String name )
{
if ( isParallelCapable )
{
return getClassLoadingLock( name );
}
else
{
return this;
}
}
public Class loadClassFromParent( String name )
{
ClassLoader parent = getParentClassLoader();
if ( parent != null && isImportedFromParent( name ) )
{
try
{
return parent.loadClass( name );
}
catch ( ClassNotFoundException e )
{
return null;
}
}
return null;
}
//---------------------------------------------------------------------------------------------
// Search methods that can be ordered by strategies to get a resource
//---------------------------------------------------------------------------------------------
public URL loadResourceFromImport( String name )
{
ClassLoader importClassLoader = getImportClassLoader( name );
if ( importClassLoader != null )
{
return importClassLoader.getResource( name );
}
return null;
}
public URL loadResourceFromSelf( String name )
{
return super.findResource( name );
}
public URL loadResourceFromParent( String name )
{
ClassLoader parent = getParentClassLoader();
if ( parent != null && isImportedFromParent( name ) )
{
return parent.getResource( name );
}
else
{
return null;
}
}
//---------------------------------------------------------------------------------------------
// Search methods that can be ordered by strategies to get resources
//---------------------------------------------------------------------------------------------
public Enumeration loadResourcesFromImport( String name )
{
ClassLoader importClassLoader = getImportClassLoader( name );
if ( importClassLoader != null )
{
try
{
return importClassLoader.getResources( name );
}
catch ( IOException e )
{
return null;
}
}
return null;
}
public Enumeration loadResourcesFromSelf( String name )
{
try
{
return super.findResources( name );
}
catch ( IOException e )
{
return null;
}
}
public Enumeration loadResourcesFromParent( String name )
{
ClassLoader parent = getParentClassLoader();
if ( parent != null && isImportedFromParent( name ) )
{
try
{
return parent.getResources( name );
}
catch ( IOException e )
{
// eat it
}
}
return null;
}
static
{
if (isParallelCapable) // Avoid running this method on older jdks
{
registerAsParallelCapable();
}
}
}
DuplicateRealmException.java 0000664 0000000 0000000 00000003655 12203204422 0040605 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.ClassWorldException;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Indicates an attempt to add a ClassRealm to a
* ClassWorld with a duplicate id.
*
* @author bob mcwhirter
*/
public class DuplicateRealmException
extends ClassWorldException
{
// ------------------------------------------------------------
// Instance members
// ------------------------------------------------------------
/**
* The realm id.
*/
private String id;
// ------------------------------------------------------------
// Constructors
// ------------------------------------------------------------
/**
* Construct.
*
* @param world The world.
* @param id The realm id.
*/
public DuplicateRealmException( ClassWorld world, String id )
{
super( world, id );
this.id = id;
}
// ------------------------------------------------------------
// Instance methods
// ------------------------------------------------------------
/**
* Retrieve the duplicate realm id.
*
* @return The id.
*/
public String getId()
{
return this.id;
}
}
Entry.java 0000664 0000000 0000000 00000014766 12203204422 0035141 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Import description entry.
*
* @author bob mcwhirter
*/
class Entry
implements Comparable
{
final ClassLoader classLoader;
final String pkgName;
Entry( ClassLoader realm, String pkgName )
{
this.classLoader = realm;
this.pkgName = pkgName;
}
// ------------------------------------------------------------
// Instance methods
// ------------------------------------------------------------
/**
* Retrieve the class loader.
*
* @return The class loader.
*/
ClassLoader getClassLoader()
{
return this.classLoader;
}
/**
* Retrieve the package name.
*
* @return The package name.
*/
String getPackageName()
{
return this.pkgName;
}
/**
* Determine if the class/resource name matches the package
* described by this entry.
*
* @param name The class or resource name to test, must not be null.
* @return true if this entry matches the
* classname, otherwise false.
*/
boolean matches( String name )
{
String pkg = getPackageName();
if ( pkg.endsWith( ".*" ) )
{
String pkgName;
if ( name.indexOf( '/' ) < 0 )
{
// a binary class name, e.g. java.lang.Object
int index = name.lastIndexOf( '.' );
pkgName = ( index < 0 ) ? "" : name.substring( 0, index );
}
else
{
// a resource name, e.g. java/lang/Object.class
int index = name.lastIndexOf( '/' );
pkgName = ( index < 0 ) ? "" : name.substring( 0, index ).replace( '/', '.' );
}
return pkgName.length() == pkg.length() - 2 && pkg.regionMatches( 0, pkgName, 0, pkgName.length() );
}
else if ( pkg.length() > 0 )
{
if ( name.indexOf( '/' ) < 0 )
{
// a binary class name, e.g. java.lang.Object
if ( name.startsWith( pkg ) )
{
if ( name.length() == pkg.length() )
{
// exact match of class name
return true;
}
else if ( name.charAt( pkg.length() ) == '.' )
{
// prefix match of package name
return true;
}
else if ( name.charAt( pkg.length() ) == '$' )
{
// prefix match of enclosing type
return true;
}
}
}
else
{
// a resource name, e.g. java/lang/Object.class
if ( name.equals( pkg ) )
{
// exact match of resource name
return true;
}
pkg = pkg.replace( '.', '/' );
if ( name.startsWith( pkg ) && name.length() > pkg.length() )
{
if ( name.charAt( pkg.length() ) == '/' )
{
// prefix match of package directory
return true;
}
else if ( name.charAt( pkg.length() ) == '$' )
{
// prefix match of nested class file
return true;
}
else if ( name.length() == pkg.length() + 6 && name.endsWith( ".class" ) )
{
// exact match of class file
return true;
}
}
}
return false;
}
else
{
return true;
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// java.lang.Comparable
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/**
* Compare this entry to another for relative ordering.
*
*
* The natural ordering of Entry objects is reverse-alphabetical
* based upon package name.
*
*
* @param thatObj The object to compare.
* @return -1 if this object sorts before that object, 0
* if they are equal, or 1 if this object sorts
* after that object.
*/
public int compareTo( Entry that )
{
// We are reverse sorting this list, so that
// we get longer matches first:
//
// com.werken.foo.bar
// com.werken.foo
// com.werken
return - ( getPackageName().compareTo( that.getPackageName() ) );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// java.lang.Object
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/**
* Test this entry for equality to another.
*
*
* Consistent with {@link #compareTo}, this method tests
* for equality purely on the package name.
*
*
* @param thatObj The object to compare
* @return true if the two objects are
* semantically equivalent, otherwise false.
*/
public boolean equals( Object thatObj )
{
Entry that = (Entry) thatObj;
return getPackageName().equals( that.getPackageName() );
}
/**
*
* Consistent with {@link #equals}, this method creates a hashCode
* based on the packagename.
*
*/
public int hashCode()
{
return getPackageName().hashCode();
}
public String toString()
{
return "Entry[import " + getPackageName() + " from realm " + getClassLoader() + "]";
}
}
NoSuchRealmException.java 0000664 0000000 0000000 00000003653 12203204422 0040070 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.ClassWorldException;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Indicates an attempt to retrieve a ClassRealm from a
* ClassWorld with an invalid id.
*
* @author bob mcwhirter
*/
public class NoSuchRealmException
extends ClassWorldException
{
// ------------------------------------------------------------
// Instance members
// ------------------------------------------------------------
/**
* The realm id.
*/
private String id;
// ------------------------------------------------------------
// Constructors
// ------------------------------------------------------------
/**
* Construct.
*
* @param world The world.
* @param id The realm id.
*/
public NoSuchRealmException( ClassWorld world, String id )
{
super( world, id );
this.id = id;
}
// ------------------------------------------------------------
// Instance methods
// ------------------------------------------------------------
/**
* Retrieve the invalid realm id.
*
* @return The id.
*/
public String getId()
{
return this.id;
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy/ 0000775 0000000 0000000 00000000000 12203204422 0034000 5 ustar 00root root 0000000 0000000 AbstractStrategy.java 0000664 0000000 0000000 00000003554 12203204422 0040061 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import org.codehaus.plexus.classworlds.UrlUtils;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Jason van Zyl
*/
public abstract class AbstractStrategy
implements Strategy
{
protected ClassRealm realm;
public AbstractStrategy( ClassRealm realm )
{
this.realm = realm;
}
protected String getNormalizedResource( String name )
{
return UrlUtils.normalizeUrlPath( name );
}
protected Enumeration combineResources( Enumeration en1, Enumeration en2, Enumeration en3 )
{
Collection urls = new LinkedHashSet();
addAll( urls, en1 );
addAll( urls, en2 );
addAll( urls, en3 );
return Collections.enumeration( urls );
}
private void addAll( Collection target, Enumeration en )
{
if ( en != null )
{
while ( en.hasMoreElements() )
{
target.add( en.nextElement() );
}
}
}
public ClassRealm getRealm()
{
return realm;
}
}
OsgiBundleStrategy.java 0000664 0000000 0000000 00000005160 12203204422 0040344 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2010 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
public class OsgiBundleStrategy
extends AbstractStrategy
{
// java.* from parent
// imported packages [Import-Package header with explicit constraints on the exporter]
// requires bundle [Required-Bundle]
// self [Bundle-Classpath header]
// attached fragments
//
// We need to trya and be OSGi r4 compliant in the loading of all the bundles so that we can try to
// load eclipse without requiring equinox. Or any other OSGi container for that matter.
public OsgiBundleStrategy( ClassRealm realm )
{
super( realm );
}
public Class loadClass( String name )
throws ClassNotFoundException
{
Class clazz = realm.loadClassFromImport( name );
if ( clazz == null )
{
clazz = realm.loadClassFromSelf( name );
if ( clazz == null )
{
clazz = realm.loadClassFromParent( name );
if ( clazz == null )
{
throw new ClassNotFoundException( name );
}
}
}
return clazz;
}
public URL getResource( String name )
{
URL resource = realm.loadResourceFromImport( name );
if ( resource == null )
{
resource = realm.loadResourceFromSelf( name );
if ( resource == null )
{
resource = realm.loadResourceFromParent( name );
}
}
return resource;
}
public Enumeration getResources( String name )
throws IOException
{
Enumeration imports = realm.loadResourcesFromImport( name );
Enumeration self = realm.loadResourcesFromSelf( name );
Enumeration parent = realm.loadResourcesFromParent( name );
return combineResources( imports, self, parent );
}
}
ParentFirstStrategy.java 0000664 0000000 0000000 00000004342 12203204422 0040553 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
/**
* @author Jason van Zyl
*/
public class ParentFirstStrategy
extends AbstractStrategy
{
public ParentFirstStrategy( ClassRealm realm )
{
super( realm );
}
public Class loadClass( String name )
throws ClassNotFoundException
{
Class clazz = realm.loadClassFromImport( name );
if ( clazz == null )
{
clazz = realm.loadClassFromParent( name );
if ( clazz == null )
{
clazz = realm.loadClassFromSelf( name );
if ( clazz == null )
{
throw new ClassNotFoundException( name );
}
}
}
return clazz;
}
public URL getResource( String name )
{
URL resource = realm.loadResourceFromImport( name );
if ( resource == null )
{
resource = realm.loadResourceFromParent( name );
if ( resource == null )
{
resource = realm.loadResourceFromSelf( name );
}
}
return resource;
}
public Enumeration getResources( String name )
throws IOException
{
Enumeration imports = realm.loadResourcesFromImport( name );
Enumeration parent = realm.loadResourcesFromParent( name );
Enumeration self = realm.loadResourcesFromSelf( name );
return combineResources( imports, parent, self );
}
}
SelfFirstStrategy.java 0000664 0000000 0000000 00000004336 12203204422 0040216 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
/**
* @author Jason van Zyl
*/
public class SelfFirstStrategy
extends AbstractStrategy
{
public SelfFirstStrategy( ClassRealm realm )
{
super( realm );
}
public Class loadClass( String name )
throws ClassNotFoundException
{
Class clazz = realm.loadClassFromImport( name );
if ( clazz == null )
{
clazz = realm.loadClassFromSelf( name );
if ( clazz == null )
{
clazz = realm.loadClassFromParent( name );
if ( clazz == null )
{
throw new ClassNotFoundException( name );
}
}
}
return clazz;
}
public URL getResource( String name )
{
URL resource = realm.loadResourceFromImport( name );
if ( resource == null )
{
resource = realm.loadResourceFromSelf( name );
if ( resource == null )
{
resource = realm.loadResourceFromParent( name );
}
}
return resource;
}
public Enumeration getResources( String name )
throws IOException
{
Enumeration imports = realm.loadResourcesFromImport( name );
Enumeration self = realm.loadResourcesFromSelf( name );
Enumeration parent = realm.loadResourcesFromParent( name );
return combineResources( imports, self, parent );
}
}
Strategy.java 0000664 0000000 0000000 00000002271 12203204422 0036370 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
/**
* A strategy is a class for defining how classes and resources are located
* in classworlds.
*
* @uthor: Andrew Williams
* @since: Nov 19, 2006
*/
public interface Strategy
{
Class loadClass( String name )
throws ClassNotFoundException;
URL getResource( String name );
Enumeration getResources( String name )
throws IOException;
ClassRealm getRealm();
}
StrategyFactory.java 0000664 0000000 0000000 00000002300 12203204422 0037711 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/main/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.codehaus.plexus.classworlds.realm.ClassRealm;
/**
* StrategyFactory loads a strategy, either default or from a given hint.
*
* @uthor: Andrew Williams
* @since: Nov 19, 2006
*/
public class StrategyFactory
{
public static Strategy getStrategy( ClassRealm realm )
{
return getStrategy( realm, "default" );
}
public static Strategy getStrategy( ClassRealm realm, String hint )
{
// TODO: Here we shall check hint to load non-default strategies
return new SelfFirstStrategy( realm );
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/site/ 0000775 0000000 0000000 00000000000 12203204422 0022773 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/site/site.xml 0000664 0000000 0000000 00000001127 12203204422 0024462 0 ustar 00root root 0000000 0000000
plexus-classworlds-plexus-classworlds-2.5.1/src/test/ 0000775 0000000 0000000 00000000000 12203204422 0023006 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/ 0000775 0000000 0000000 00000000000 12203204422 0023727 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/ 0000775 0000000 0000000 00000000000 12203204422 0024516 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12203204422 0026311 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12203204422 0027631 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/ 0000775 0000000 0000000 00000000000 12203204422 0032171 5 ustar 00root root 0000000 0000000 AbstractClassWorldsTestCase.java 0000664 0000000 0000000 00000002002 12203204422 0040327 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds package org.codehaus.plexus.classworlds;
import java.net.URL;
import junit.framework.TestCase;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Jason van Zyl
*/
public abstract class AbstractClassWorldsTestCase
extends TestCase
{
public AbstractClassWorldsTestCase( String string )
{
super( string );
}
protected URL getJarUrl( String jarName )
{
return TestUtil.getTestResourceUrl( jarName );
}
}
ClassView.java 0000664 0000000 0000000 00000007404 12203204422 0034662 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds package org.codehaus.plexus.classworlds;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
public class ClassView
{
/**
* * Formats Class information for debug output purposes.
* *
* * @param clz the Class to print information for
* *
* * @return a String describing the Class in detail
*/
public static String toString( Class clz )
{
if ( clz.isPrimitive() )
{
return clz.toString();
}
else if ( clz.isArray() )
{
return "Array of " + toString( clz.getComponentType() );
}
else if ( clz.isInterface() )
{
return toInterfaceString( clz, "" );
}
else
{
return toClassString( clz, "" );
}
}
/**
* * Formats Class information for debug output purposes.
* *
* * @param clz the Class to print information for
* * @param sIndent the indentation to precede each line of output
* *
* * @return a String describing the Class in detail
*/
private static String toClassString( Class clz, String sIndent )
{
StringBuffer sb = new StringBuffer();
sb.append( sIndent )
.append( "Class " )
.append( clz.getName() )
.append( " (" )
.append( toString( clz.getClassLoader() ) )
.append( ')' );
sIndent += " ";
Class[] aclz = clz.getInterfaces();
for ( int i = 0, c = aclz.length; i < c; ++i )
{
sb.append( '\n' )
.append( toInterfaceString( aclz[i], sIndent ) );
}
clz = clz.getSuperclass();
if ( clz != null )
{
sb.append( '\n' )
.append( toClassString( clz, sIndent ) );
}
return sb.toString();
}
/**
* * Formats interface information for debug output purposes.
* *
* * @param clz the interface Class to print information for
* * @param sIndent the indentation to precede each line of output
* *
* * @return a String describing the interface Class in detail
*/
private static String toInterfaceString( Class clz, String sIndent )
{
StringBuffer sb = new StringBuffer();
sb.append( sIndent )
.append( "Interface " )
.append( clz.getName() )
.append( " (" )
.append( toString( clz.getClassLoader() ) )
.append( ')' );
Class[] aclz = clz.getInterfaces();
for ( int i = 0, c = aclz.length; i < c; ++i )
{
clz = aclz[i];
sb.append( '\n' )
.append( toInterfaceString( clz, sIndent + " " ) );
}
return sb.toString();
}
/**
* * Format a description for the specified ClassLoader object.
* *
* * @param loader the ClassLoader instance (or null)
* *
* * @return a String description of the ClassLoader
*/
private static String toString( ClassLoader loader )
{
if ( loader == null )
{
return "System ClassLoader";
}
return "ClassLoader class=" + loader.getClass().getName() + ", hashCode=" + loader.hashCode();
}
}
ClassWorldTest.java 0000664 0000000 0000000 00000010647 12203204422 0035702 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds package org.codehaus.plexus.classworlds;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
import org.codehaus.plexus.classworlds.realm.NoSuchRealmException;
public class ClassWorldTest
extends AbstractClassWorldsTestCase
{
private ClassWorld world;
public ClassWorldTest( String name )
{
super( name );
}
public void setUp()
{
this.world = new ClassWorld();
}
public void tearDown()
{
this.world = null;
}
public void testEmpty()
{
assertTrue( this.world.getRealms().isEmpty() );
}
public void testNewRealm()
throws Exception
{
ClassRealm realm = this.world.newRealm( "foo" );
assertNotNull( realm );
}
public void testGetRealm()
throws Exception
{
ClassRealm realm = this.world.newRealm( "foo" );
assertSame( realm, this.world.getRealm( "foo" ) );
}
public void testNewRealm_Duplicate()
throws Exception
{
try
{
this.world.newRealm( "foo" );
this.world.newRealm( "foo" );
fail( "throw DuplicateRealmException" );
}
catch ( DuplicateRealmException e )
{
// expected and correct
assertSame( this.world, e.getWorld() );
assertEquals( "foo", e.getId() );
}
}
public void testGetRealm_NoSuch()
throws Exception
{
try
{
this.world.getRealm( "foo" );
fail( "throw NoSuchRealmException" );
}
catch ( NoSuchRealmException e )
{
// expected and correct
assertSame( this.world, e.getWorld() );
assertEquals( "foo", e.getId() );
}
}
public void testGetRealms()
throws Exception
{
assertTrue( this.world.getRealms().isEmpty() );
ClassRealm foo = this.world.newRealm( "foo" );
assertEquals( 1, this.world.getRealms().size() );
assertTrue( this.world.getRealms().contains( foo ) );
ClassRealm bar = this.world.newRealm( "bar" );
assertEquals( 2, this.world.getRealms().size() );
assertTrue( this.world.getRealms().contains( bar ) );
}
public void testPLX334()
throws Exception
{
ClassLoader loader = new URLClassLoader( new URL[] { getJarUrl( "component1-1.0.jar" ) } );
world.newRealm( "netbeans", loader );
ClassRealm plexus = world.newRealm( "plexus" );
plexus.importFrom( "netbeans", "META-INF/plexus" );
plexus.importFrom( "netbeans", "org.codehaus.plexus" );
Enumeration e = plexus.getResources( "META-INF/plexus/components.xml" );
assertNotNull( e );
int resourceCount = 0;
for ( Enumeration resources = e; resources.hasMoreElements(); )
{
URL obj = resources.nextElement();
assertTrue( obj.getPath().indexOf( "/component1-1.0.jar!/META-INF/plexus/components.xml" ) >= 0 );
resourceCount++;
}
// assertEquals( 2, resourceCount );
// for some reason surefire-plugin 2.3 returned 2 items there:
// for example:
//jar:file:/home/mkleint/.m2/repository/org/codehaus/plexus/plexus-archiver/1.0-alpha-7/plexus-archiver-1.0-alpha-7.jar!/META-INF/plexus/components.xml
//jar:file:/home/mkleint/src/plexus-trunk/plexus-classworlds/src/test-jars/component1-1.0.jar!/META-INF/plexus/components.xml
// However only 1 is correct, which is actually returned by the 2.4 surefire-plugin
assertEquals( 1, resourceCount );
Class c = plexus.loadClass( "org.codehaus.plexus.Component1" );
assertNotNull( c );
}
}
TestUtil.java 0000664 0000000 0000000 00000003107 12203204422 0034533 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds package org.codehaus.plexus.classworlds;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
/**
* @author Ben Walding
*/
public class TestUtil
{
public static URL getTestResourceUrl( String resourceName )
{
File baseDir = new File( getBasedir() );
File testDir = new File( baseDir, "src/test/test-data" );
File resourceFile = new File( testDir, resourceName );
try
{
return resourceFile.toURI().toURL();
}
catch ( MalformedURLException e )
{
throw new RuntimeException( e );
}
}
public static String getBasedir()
{
String basedir = System.getProperty( "basedir" );
/* do our best if we are not running from surefire */
if ( basedir == null || basedir.length() <= 0 )
{
basedir = ( new File( "" ) ).getAbsolutePath();
}
return basedir;
}
}
UrlUtilsTest.java 0000664 0000000 0000000 00000002136 12203204422 0035402 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds package org.codehaus.plexus.classworlds;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import junit.framework.TestCase;
public class UrlUtilsTest
extends TestCase
{
public void testNormalizeUrlPath()
{
assertEquals( "org/codehaus/Test.class", UrlUtils.normalizeUrlPath( "org/codehaus/Test.class" ) );
assertEquals( "org/Test.class", UrlUtils.normalizeUrlPath( "org/codehaus/../Test.class" ) );
assertEquals( "../../some.jar/org/Test.class", UrlUtils.normalizeUrlPath( "../../some.jar/org/Test.class" ) );
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/launcher/ 0000775 0000000 0000000 00000000000 12203204422 0033772 5 ustar 00root root 0000000 0000000 ConfigurationParserTest.java 0000664 0000000 0000000 00000005417 12203204422 0041411 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/launcher package org.codehaus.plexus.classworlds.launcher;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
public class ConfigurationParserTest
extends AbstractClassWorldsTestCase
{
ConfigurationParser configurator = new ConfigurationParser( null, System.getProperties() );
public ConfigurationParserTest( String string )
{
super( string );
}
public void testFilter_Unterminated()
throws Exception
{
try
{
this.configurator.filter( "${cheese" );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "Unterminated" ) );
}
}
public void testFilter_Solitary()
throws Exception
{
System.setProperty( "classworlds.test.prop", "test prop value" );
String result = this.configurator.filter( "${classworlds.test.prop}" );
assertEquals( "test prop value", result );
}
public void testFilter_AtStart()
throws Exception
{
System.setProperty( "classworlds.test.prop", "test prop value" );
String result = this.configurator.filter( "${classworlds.test.prop}cheese" );
assertEquals( "test prop valuecheese", result );
}
public void testFilter_AtEnd()
throws Exception
{
System.setProperty( "classworlds.test.prop", "test prop value" );
String result = this.configurator.filter( "cheese${classworlds.test.prop}" );
assertEquals( "cheesetest prop value", result );
}
public void testFilter_Multiple()
throws Exception
{
System.setProperty( "classworlds.test.prop.one", "test prop value one" );
System.setProperty( "classworlds.test.prop.two", "test prop value two" );
String result =
this.configurator.filter( "I like ${classworlds.test.prop.one} and ${classworlds.test.prop.two} a lot" );
assertEquals( "I like test prop value one and test prop value two a lot", result );
}
public void testFilter_NonExistent()
throws Exception
{
try
{
this.configurator.filter( "${gollygeewillikers}" );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "No such property" ) );
}
}
public void testFilter_InMiddle()
throws Exception
{
System.setProperty( "classworlds.test.prop", "test prop value" );
String result = this.configurator.filter( "cheese${classworlds.test.prop}toast" );
assertEquals( "cheesetest prop valuetoast", result );
}
}
ConfiguratorTest.java 0000664 0000000 0000000 00000026325 12203204422 0040070 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/launcher package org.codehaus.plexus.classworlds.launcher;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.net.URL;
import java.util.Collection;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.TestUtil;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.classworlds.realm.DuplicateRealmException;
public class ConfiguratorTest
extends AbstractClassWorldsTestCase
{
private Launcher launcher;
private Configurator configurator;
public ConfiguratorTest( String name )
{
super( name );
}
public void setUp()
{
this.launcher = new Launcher();
this.configurator = new Configurator( this.launcher );
}
public void tearDown()
{
this.launcher = null;
this.configurator = null;
System.getProperties().remove( "set.using.existent" );
System.getProperties().remove( "set.using.default" );
System.getProperties().remove( "set.using.nonexistent" );
System.getProperties().remove( "set.using.nonexistent.default" );
System.getProperties().remove( "set.using.missing" );
System.getProperties().remove( "set.using.filtered.default" );
}
public void testConfigure_Nonexistent()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "notfound.conf" ) );
fail( "throw FileNotFoundException" );
}
catch ( FileNotFoundException e )
{
// expected and correct
}
}
public void testConfigure_DuplicateMain()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "dupe-main.conf" ) );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "Duplicate main" ) );
}
}
public void testConfigure_DuplicateRealm()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "dupe-realm.conf" ) );
fail( "throw DuplicateRealmException" );
}
catch ( DuplicateRealmException e )
{
// expected and correct
assertEquals( "dupe.realm", e.getId() );
}
}
public void testConfigure_EarlyImport()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "early-import.conf" ) );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "Unhandled import" ) );
}
}
public void testConfigure_RealmSyntax()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "realm-syntax.conf" ) );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "Invalid realm" ) );
}
}
public void testConfigure_Valid()
throws Exception
{
this.configurator.configure( getConfigPath( "valid.conf" ) );
assertEquals( "org.apache.maven.app.App", this.launcher.getMainClassName() );
assertEquals( "maven", this.launcher.getMainRealmName() );
ClassWorld world = this.launcher.getWorld();
Collection realms = world.getRealms();
assertEquals( 4, realms.size() );
assertNotNull( world.getRealm( "ant" ) );
assertNotNull( world.getRealm( "maven" ) );
assertNotNull( world.getRealm( "xml" ) );
ClassRealm antRealm = world.getRealm( "ant" );
ClassRealm mavenRealm = world.getRealm( "maven" );
ClassRealm xmlRealm = world.getRealm( "xml" );
ClassRealm globRealm = world.getRealm( "glob" );
assertSame( null, antRealm.getImportClassLoader( "org.apache.tools.Ant" ) );
assertSame( xmlRealm, antRealm.getImportClassLoader( "org.xml.sax.SAXException" ) );
assertSame( null, mavenRealm.getImportClassLoader( "org.apache.maven.app.App" ) );
assertSame( xmlRealm, mavenRealm.getImportClassLoader( "org.xml.sax.SAXException" ) );
URL[] urls = globRealm.getURLs();
String basedir = TestUtil.getBasedir();
assertArrayContains( urls, new File( basedir, "src/test/test-data/nested.jar" ).toURI().toURL() );
assertArrayContains( urls, new File( basedir, "src/test/test-data/a.jar" ).toURI().toURL() );
assertArrayContains( urls, new File( basedir, "src/test/test-data/b.jar" ).toURI().toURL() );
assertArrayContains( urls, new File( basedir, "src/test/test-data/c.jar" ).toURI().toURL() );
}
public void testConfigure_Optionally_NonExistent()
throws Exception
{
this.configurator.configure( getConfigPath( "optionally-nonexistent.conf" ) );
assertEquals( "org.apache.maven.app.App", this.launcher.getMainClassName() );
assertEquals( "opt", this.launcher.getMainRealmName() );
ClassWorld world = this.launcher.getWorld();
Collection realms = world.getRealms();
assertEquals( 1, realms.size() );
assertNotNull( world.getRealm( "opt" ) );
ClassRealm optRealm = world.getRealm( "opt" );
URL[] urls = optRealm.getURLs();
assertEquals( "no urls", 0, urls.length );
}
public void testConfigure_Optionally_Existent()
throws Exception
{
this.configurator.configure( getConfigPath( "optionally-existent.conf" ) );
assertEquals( "org.apache.maven.app.App", this.launcher.getMainClassName() );
assertEquals( "opt", this.launcher.getMainRealmName() );
ClassWorld world = this.launcher.getWorld();
Collection realms = world.getRealms();
assertEquals( 1, realms.size() );
assertNotNull( world.getRealm( "opt" ) );
ClassRealm optRealm = world.getRealm( "opt" );
URL[] urls = optRealm.getURLs();
assertEquals( "one url", 1, urls.length );
assertSame( null, optRealm.getImportClassLoader( "org.xml.sax.SAXException" ) );
}
public void testConfigure_Unhandled()
throws Exception
{
try
{
this.configurator.configure( getConfigPath( "unhandled.conf" ) );
fail( "throw ConfigurationException" );
}
catch ( ConfigurationException e )
{
// expected and correct
assertTrue( e.getMessage().startsWith( "Unhandled configuration" ) );
}
}
public void testSet_Using_Existent()
throws Exception
{
assertNull( System.getProperty( "set.using.existent" ) );
this.configurator.configure( getConfigPath( "set-using-existent.conf" ) );
assertEquals( "testSet_Using_Existent", System.getProperty( "set.using.existent" ) );
}
public void testSet_Using_NonExistent()
throws Exception
{
assertNull( System.getProperty( "set.using.nonexistent" ) );
this.configurator.configure( getConfigPath( "set-using-nonexistent.conf" ) );
assertNull( System.getProperty( "set.using.nonexistent" ) );
}
public void testSet_Using_NonExistent_Default()
throws Exception
{
assertNull( System.getProperty( "set.using.nonexistent.default" ) );
this.configurator.configure( getConfigPath( "set-using-nonexistent.conf" ) );
assertEquals( "testSet_Using_NonExistent_Default", System.getProperty( "set.using.nonexistent.default" ) );
}
public void testSet_Using_NonExistent_Override()
throws Exception
{
assertNull( System.getProperty( "set.using.default" ) );
System.setProperty( "set.using.default", "testSet_Using_NonExistent_Override" );
this.configurator.configure( getConfigPath( "set-using-nonexistent.conf" ) );
assertEquals( "testSet_Using_NonExistent_Override", System.getProperty( "set.using.default" ) );
}
public void testSet_Using_Existent_Override()
throws Exception
{
assertNull( System.getProperty( "set.using.existent" ) );
System.setProperty( "set.using.existent", "testSet_Using_Existent_Override" );
this.configurator.configure( getConfigPath( "set-using-existent.conf" ) );
assertEquals( "testSet_Using_Existent_Override", System.getProperty( "set.using.existent" ) );
}
public void testSet_Using_Existent_Default()
throws Exception
{
assertNull( System.getProperty( "set.using.default" ) );
this.configurator.configure( getConfigPath( "set-using-existent.conf" ) );
assertEquals( "testSet_Using_Existent_Default", System.getProperty( "set.using.default" ) );
}
public void testSet_Using_Missing_Default()
throws Exception
{
assertNull( System.getProperty( "set.using.missing" ) );
this.configurator.configure( getConfigPath( "set-using-missing.conf" ) );
assertEquals( "testSet_Using_Missing_Default", System.getProperty( "set.using.missing" ) );
}
public void testSet_Using_Missing_Override()
throws Exception
{
assertNull( System.getProperty( "set.using.missing" ) );
System.setProperty( "set.using.missing", "testSet_Using_Missing_Override" );
this.configurator.configure( getConfigPath( "set-using-missing.conf" ) );
assertEquals( "testSet_Using_Missing_Override", System.getProperty( "set.using.missing" ) );
}
public void testSet_Using_Filtered_Default()
throws Exception
{
assertNull( System.getProperty( "set.using.filtered.default" ) );
this.configurator.configure( getConfigPath( "set-using-missing.conf" ) );
assertEquals( System.getProperty( "user.home" ) + "/m2", System.getProperty( "set.using.filtered.default" ) );
}
private FileInputStream getConfigPath( String name )
throws Exception
{
return new FileInputStream(
new File( new File( TestUtil.getBasedir(), "src/test/test-data" ), name ) );
}
private void assertArrayContains( URL[] array,
URL url )
throws Exception
{
for ( int i = 0; i < array.length; ++i )
{
if ( url.equals( array[i] ) )
{
return;
}
}
fail( "URL (" + url + ") not found in array of URLs" );
}
}
LauncherTest.java 0000664 0000000 0000000 00000007140 12203204422 0037161 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/launcher package org.codehaus.plexus.classworlds.launcher;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.TestUtil;
public class LauncherTest
extends AbstractClassWorldsTestCase
{
private Launcher launcher;
public LauncherTest( String name )
{
super( name );
}
public void setUp()
{
System.setProperty( "java.protocol.handler.pkgs", "org.codehaus.classworlds.protocol" );
this.launcher = new Launcher();
this.launcher.setSystemClassLoader( Thread.currentThread().getContextClassLoader() );
}
public void tearDown()
{
this.launcher = null;
}
public void testConfigure_Valid()
throws Exception
{
launcher.configure( getConfigPath( "valid-launch.conf" ) );
Class mainClass = launcher.getMainClass();
assertNotNull( mainClass );
assertEquals( "a.A", mainClass.getName() );
assertEquals( "app", launcher.getMainRealm().getId() );
}
public void testLaunch_ValidStandard()
throws Exception
{
launcher.configure( getConfigPath( "valid-launch.conf" ) );
launcher.launch( new String[]{} );
}
public void testLaunch_ValidStandardExitCode()
throws Exception
{
launcher.configure( getConfigPath( "valid-launch-exitCode.conf" ) );
launcher.launch( new String[]{} );
assertEquals( "check exit code", 15, launcher.getExitCode() );
}
public void testLaunch_ValidEnhanced()
throws Exception
{
launcher.configure( getConfigPath( "valid-enh-launch.conf" ) );
launcher.launch( new String[]{} );
}
public void testLaunch_ValidEnhancedExitCode()
throws Exception
{
launcher.configure( getConfigPath( "valid-enh-launch-exitCode.conf" ) );
launcher.launch( new String[]{} );
assertEquals( "check exit code", 45, launcher.getExitCode() );
}
public void testLaunch_NoSuchMethod()
throws Exception
{
launcher.configure( getConfigPath( "launch-nomethod.conf" ) );
try
{
launcher.launch( new String[]{} );
fail( "should have thrown NoSuchMethodException" );
}
catch ( NoSuchMethodException e )
{
// expected and correct
}
}
public void testLaunch_ClassNotFound()
throws Exception
{
launcher.configure( getConfigPath( "launch-noclass.conf" ) );
try
{
launcher.launch( new String[]{} );
fail( "throw ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
}
private FileInputStream getConfigPath( String name )
throws Exception
{
String basedir = TestUtil.getBasedir();
return new FileInputStream( new File( new File( basedir, "src/test/test-data" ), name ) );
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/realm/ 0000775 0000000 0000000 00000000000 12203204422 0033271 5 ustar 00root root 0000000 0000000 ClassRealmImplTest.java 0000664 0000000 0000000 00000033262 12203204422 0037573 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.ClassWorld;
public class ClassRealmImplTest
extends AbstractClassWorldsTestCase
{
private ClassWorld world;
public ClassRealmImplTest( String name )
{
super( name );
}
public void setUp()
{
this.world = new ClassWorld();
}
public void tearDown()
{
this.world = null;
}
public void testNewRealm()
throws Exception
{
ClassRealm realm = this.world.newRealm( "foo" );
assertNotNull( realm );
assertSame( this.world, realm.getWorld() );
assertEquals( "foo", realm.getId() );
}
public void testLocateSourceRealm_NoImports()
throws Exception
{
ClassRealm realm = new ClassRealm( this.world, "foo", null );
assertSame( null, realm.getImportClassLoader( "com.werken.Stuff" ) );
}
public void testLocateSourceRealm_SimpleImport()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
ClassRealm werkflowRealm = this.world.newRealm( "werkflow" );
mainRealm.importFrom( "werkflow", "com.werken.werkflow" );
assertSame( werkflowRealm, mainRealm.getImportClassLoader( "com.werken.werkflow.WerkflowEngine" ) );
assertSame( werkflowRealm, mainRealm.getImportClassLoader( "com/werken/werkflow/some.properties" ) );
assertSame( werkflowRealm, mainRealm.getImportClassLoader( "com.werken.werkflow.process.ProcessManager" ) );
assertSame( null, mainRealm.getImportClassLoader( "com.werken.blissed.Process" ) );
assertSame( null, mainRealm.getImportClassLoader( "java.lang.Object" ) );
assertSame( null, mainRealm.getImportClassLoader( "NoviceProgrammerClass" ) );
}
public void testLocateSourceRealm_MultipleImport()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
ClassRealm werkflowRealm = this.world.newRealm( "werkflow" );
ClassRealm blissedRealm = this.world.newRealm( "blissed" );
mainRealm.importFrom( "werkflow", "com.werken.werkflow" );
mainRealm.importFrom( "blissed", "com.werken.blissed" );
assertSame( werkflowRealm, mainRealm.getImportClassLoader( "com.werken.werkflow.WerkflowEngine" ) );
assertSame( werkflowRealm, mainRealm.getImportClassLoader( "com.werken.werkflow.process.ProcessManager" ) );
assertSame( blissedRealm, mainRealm.getImportClassLoader( "com.werken.blissed.Process" ) );
assertSame( blissedRealm, mainRealm.getImportClassLoader( "com.werken.blissed.guard.BooleanGuard" ) );
assertSame( null, mainRealm.getImportClassLoader( "java.lang.Object" ) );
assertSame( null, mainRealm.getImportClassLoader( "NoviceProgrammerClass" ) );
}
public void testLocateSourceRealm_Hierachy()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
ClassRealm fooRealm = this.world.newRealm( "foo" );
ClassRealm fooBarRealm = this.world.newRealm( "fooBar" );
ClassRealm fooBarBazRealm = this.world.newRealm( "fooBarBaz" );
mainRealm.importFrom( "foo", "foo" );
mainRealm.importFrom( "fooBar", "foo.bar" );
mainRealm.importFrom( "fooBarBaz", "foo.bar.baz" );
assertSame( fooRealm, mainRealm.getImportClassLoader( "foo.Goober" ) );
assertSame( fooRealm, mainRealm.getImportClassLoader( "foo.cheese.Goober" ) );
assertSame( fooBarRealm, mainRealm.getImportClassLoader( "foo.bar.Goober" ) );
assertSame( fooBarRealm, mainRealm.getImportClassLoader( "foo.bar.cheese.Goober" ) );
assertSame( fooBarBazRealm, mainRealm.getImportClassLoader( "foo.bar.baz.Goober" ) );
assertSame( fooBarBazRealm, mainRealm.getImportClassLoader( "foo.bar.baz.cheese.Goober" ) );
assertSame( null, mainRealm.getImportClassLoader( "java.lang.Object" ) );
assertSame( null, mainRealm.getImportClassLoader( "NoviceProgrammerClass" ) );
}
public void testLocateSourceRealm_Hierachy_Reverse()
throws Exception
{
ClassRealm fooBarBazRealm = this.world.newRealm( "fooBarBaz" );
ClassRealm fooBarRealm = this.world.newRealm( "fooBar" );
ClassRealm fooRealm = this.world.newRealm( "foo" );
ClassRealm mainRealm = this.world.newRealm( "main" );
mainRealm.importFrom( "fooBarBaz", "foo.bar.baz" );
mainRealm.importFrom( "fooBar", "foo.bar" );
mainRealm.importFrom( "foo", "foo" );
assertSame( fooRealm, mainRealm.getImportClassLoader( "foo.Goober" ) );
assertSame( fooRealm, mainRealm.getImportClassLoader( "foo.cheese.Goober" ) );
assertSame( fooBarRealm, mainRealm.getImportClassLoader( "foo.bar.Goober" ) );
assertSame( fooBarRealm, mainRealm.getImportClassLoader( "foo.bar.cheese.Goober" ) );
assertSame( fooBarBazRealm, mainRealm.getImportClassLoader( "foo.bar.baz.Goober" ) );
assertSame( fooBarBazRealm, mainRealm.getImportClassLoader( "foo.bar.baz.cheese.Goober" ) );
assertSame( null, mainRealm.getImportClassLoader( "java.lang.Object" ) );
assertSame( null, mainRealm.getImportClassLoader( "NoviceProgrammerClass" ) );
}
public void testLoadClass_SystemClass()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
Class cls = mainRealm.loadClass( "java.lang.Object" );
assertNotNull( cls );
}
public void testLoadClass_NonSystemClass()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
try
{
Class c = mainRealm.loadClass( "com.werken.projectz.UberThing" );
System.out.println( "c = " + c );
fail( "A ClassNotFoundException should be thrown!" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
}
public void testLoadClass_ClassWorldsClass()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
Class cls = mainRealm.loadClass( "org.codehaus.plexus.classworlds.ClassWorld" );
assertNotNull( cls );
assertSame( ClassWorld.class, cls );
}
public void testLoadClass_Local()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
try
{
mainRealm.loadClass( "a.A" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
mainRealm.addURL( getJarUrl( "a.jar" ) );
Class classA = mainRealm.loadClass( "a.A" );
assertNotNull( classA );
ClassRealm otherRealm = this.world.newRealm( "other" );
try
{
otherRealm.loadClass( "a.A" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
}
public void testLoadClass_Imported()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
ClassRealm realmA = this.world.newRealm( "realmA" );
try
{
realmA.loadClass( "a.A" );
fail( "realmA.loadClass(a.A) should have thrown a ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
realmA.addURL( getJarUrl( "a.jar" ) );
try
{
mainRealm.loadClass( "a.A" );
fail( "mainRealm.loadClass(a.A) should have thrown a ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
mainRealm.importFrom( "realmA", "a" );
Class classA = realmA.loadClass( "a.A" );
assertNotNull( classA );
assertEquals( realmA, classA.getClassLoader() );
Class classMain = mainRealm.loadClass( "a.A" );
assertNotNull( classMain );
assertEquals( realmA, classMain.getClassLoader() );
assertSame( classA, classMain );
}
public void testLoadClass_Package()
throws Exception
{
ClassRealm realmA = this.world.newRealm( "realmA" );
realmA.addURL( getJarUrl( "a.jar" ) );
Class clazz = realmA.loadClass( "a.A" );
assertNotNull( clazz );
assertEquals( "a.A", clazz.getName() );
Package p = clazz.getPackage();
assertNotNull( p );
assertEquals( "p.getName()", "a", p.getName() );
}
public void testLoadClass_Complex()
throws Exception
{
ClassRealm realmA = this.world.newRealm( "realmA" );
ClassRealm realmB = this.world.newRealm( "realmB" );
ClassRealm realmC = this.world.newRealm( "realmC" );
realmA.addURL( getJarUrl( "a.jar" ) );
realmB.addURL( getJarUrl( "b.jar" ) );
realmC.addURL( getJarUrl( "c.jar" ) );
realmC.importFrom( "realmA", "a" );
realmC.importFrom( "realmB", "b" );
realmA.importFrom( "realmC", "c" );
Class classA_A = realmA.loadClass( "a.A" );
Class classB_B = realmB.loadClass( "b.B" );
Class classC_C = realmC.loadClass( "c.C" );
assertNotNull( classA_A );
assertNotNull( classB_B );
assertNotNull( classC_C );
assertEquals( realmA, classA_A.getClassLoader() );
assertEquals( realmB, classB_B.getClassLoader() );
assertEquals( realmC, classC_C.getClassLoader() );
// load from C
Class classA_C = realmC.loadClass( "a.A" );
assertNotNull( classA_C );
assertSame( classA_A, classA_C );
assertEquals( realmA, classA_C.getClassLoader() );
Class classB_C = realmC.loadClass( "b.B" );
assertNotNull( classB_C );
assertSame( classB_B, classB_C );
assertEquals( realmB, classB_C.getClassLoader() );
// load from A
Class classC_A = realmA.loadClass( "c.C" );
assertNotNull( classC_A );
assertSame( classC_C, classC_A );
assertEquals( realmC, classC_A.getClassLoader() );
try
{
realmA.loadClass( "b.B" );
fail( "throw ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
// load from B
try
{
realmB.loadClass( "a.A" );
fail( "throw ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
try
{
realmB.loadClass( "c.C" );
fail( "throw ClassNotFoundException" );
}
catch ( ClassNotFoundException e )
{
// expected and correct
}
}
public void testLoadClass_ClassWorldsClassRepeatedly()
throws Exception
{
ClassRealm mainRealm = this.world.newRealm( "main" );
for ( int i = 0; i < 100; i++ )
{
Class cls = mainRealm.loadClass( "org.codehaus.plexus.classworlds.ClassWorld" );
assertNotNull( cls );
assertSame( ClassWorld.class, cls );
}
}
public void testGetResources_BaseBeforeSelf()
throws Exception
{
String resource = "common.properties";
ClassRealm base = this.world.newRealm( "realmA" );
base.addURL( getJarUrl( "a.jar" ) );
URL baseUrl = base.getResource( resource );
assertNotNull( baseUrl );
ClassRealm sub = this.world.newRealm( "realmB", base );
sub.addURL( getJarUrl( "b.jar" ) );
URL subUrl = sub.getResource( resource );
assertNotNull( subUrl );
assertEquals( baseUrl, subUrl );
List urls = new ArrayList();
for ( Iterator it = Collections.list( sub.getResources( resource ) ).iterator(); it.hasNext(); )
{
String path = it.next().toString();
path = path.substring( path.lastIndexOf( '/', path.lastIndexOf( ".jar!" ) ) );
urls.add( path );
}
assertEquals( Arrays.asList( new String[] { "/a.jar!/common.properties", "/b.jar!/common.properties" } ), urls );
}
public void testGetResources_SelfBeforeParent()
throws Exception
{
String resource = "common.properties";
ClassRealm parent = this.world.newRealm( "realmA" );
parent.addURL( getJarUrl( "a.jar" ) );
URL parentUrl = parent.getResource( resource );
assertNotNull( parentUrl );
ClassRealm child = parent.createChildRealm( "realmB" );
child.addURL( getJarUrl( "b.jar" ) );
URL childUrl = child.getResource( resource );
assertNotNull( childUrl );
List urls = Collections.list( child.getResources( resource ) );
assertNotNull( urls );
assertEquals( Arrays.asList( new URL[] { childUrl, parentUrl } ), urls );
}
}
DefaultClassRealmTest.java 0000664 0000000 0000000 00000031000 12203204422 0040242 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collections;
import java.util.concurrent.CountDownLatch;
import org.codehaus.classworlds.ClassRealmAdapter;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.ClassWorld;
public class DefaultClassRealmTest
extends AbstractClassWorldsTestCase
{
public DefaultClassRealmTest( String name )
{
super( name );
}
// ----------------------------------------------------------------------
// Class testing
// ----------------------------------------------------------------------
public void testLoadClassFromRealm()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "component0-1.0.jar" ) );
loadClass( mainRealm, "org.codehaus.plexus.Component0" );
}
public void testLoadClassFromChildRealmWhereClassIsLocatedInParentRealm()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "component0-1.0.jar" ) );
ClassRealm childRealm = mainRealm.createChildRealm( "child" );
loadClass( childRealm, "org.codehaus.plexus.Component0" );
}
public void testLoadClassFromChildRealmWhereClassIsLocatedInGrantParentRealm()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "component0-1.0.jar" ) );
ClassRealm childRealm = mainRealm.createChildRealm( "child" );
ClassRealm grandchildRealm = childRealm.createChildRealm( "grandchild" );
loadClass( grandchildRealm, "org.codehaus.plexus.Component0" );
}
public void testLoadClassFromChildRealmWhereClassIsLocatedInBothChildRealmAndParentRealm()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "parent", null );
mainRealm.addURL( getJarUrl( "component5-1.0.jar" ) );
ClassRealm childRealm = mainRealm.createChildRealm( "child" );
childRealm.addURL( getJarUrl( "component5-2.0.jar" ) );
Class cls = loadClass( childRealm, "test.Component5" );
assertSame( childRealm, cls.getClassLoader() );
assertEquals( 1, cls.getMethods().length );
assertEquals( "printNew", cls.getMethods()[0].getName() );
}
public void testLoadNonExistentClass()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "component0-1.0.jar" ) );
try
{
mainRealm.loadClass( "org.foo.bar.NonExistentClass" );
fail( "A ClassNotFoundException should have been thrown!" );
}
catch ( ClassNotFoundException e )
{
// expected
}
}
public void testImport()
throws Exception
{
ClassWorld world = new ClassWorld();
ClassRealm r0 = world.newRealm( "r0" );
ClassRealm r1 = world.newRealm( "r1" );
r0.addURL( getJarUrl( "component0-1.0.jar" ) );
r1.importFrom( "r0", "org.codehaus.plexus" );
loadClass( r1, "org.codehaus.plexus.Component0" );
}
public void testParentImport()
throws Exception
{
ClassWorld world = new ClassWorld();
ClassRealm parent = world.newRealm( "parent" );
ClassRealm child = world.newRealm( "child" );
parent.addURL( getJarUrl( "component0-1.0.jar" ) );
child.setParentRealm( parent );
Class type = loadClass( child, "org.codehaus.plexus.Component0" );
child.importFromParent( "non-existing" );
assertSame( null, loadClassOrNull( child, "org.codehaus.plexus.Component0" ) );
child.importFromParent( "org.codehaus.plexus" );
assertSame( type, loadClass( child, "org.codehaus.plexus.Component0" ) );
}
public void testLoadClassFromBaseClassLoaderBeforeSelf()
throws Exception
{
ClassWorld world = new ClassWorld();
ClassRealm base = world.newRealm( "base" );
base.addURL( getJarUrl( "a.jar" ) );
ClassRealm child = world.newRealm( "child", base );
child.addURL( getJarUrl( "a.jar" ) );
Class baseClass = loadClass( base, "a.A" );
Class childClass = loadClass( child, "a.A" );
assertSame( base, baseClass.getClassLoader() );
assertSame( base, childClass.getClassLoader() );
assertSame( baseClass, childClass );
}
public void testLoadClassFromRealmWithCircularClassReferences()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "circular-0.1.jar" ) );
/*
* This was reported to fail with a ClassCircularityError in IBM JDK 1.5.0-SR2, 1.5.0-SR7 and 1.6.0-SR2. It
* works in IBM JDK 1.5.0-SR10 and 1.6.0-SR6.
*/
loadClass( mainRealm, "A$C" );
}
// ----------------------------------------------------------------------
// Resource testing
// ----------------------------------------------------------------------
public void testResource()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "component0-1.0.jar" ) );
getResource( mainRealm, "META-INF/plexus/components.xml" );
}
public void testMalformedResource()
throws Exception
{
URL jarUrl = getJarUrl( "component0-1.0.jar" );
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( jarUrl );
ClassLoader officialClassLoader = new URLClassLoader( new URL[] { jarUrl } );
String resource = "META-INF/plexus/components.xml";
assertNotNull( mainRealm.getResource( resource ) );
assertNotNull( officialClassLoader.getResource( resource ) );
/*
* NOTE: Resource names with a leading slash are invalid when passed to a class loader and must not be found!
* One can use a leading slash in Class.getResource() but not in ClassLoader.getResource().
*/
assertSame( null, mainRealm.getResource( "/" + resource ) );
assertSame( null, officialClassLoader.getResource( "/" + resource ) );
/*
* For backward-compat, legacy class realms have to support leading slashes.
*/
org.codehaus.classworlds.ClassRealm legacyRealm = ClassRealmAdapter.getInstance( mainRealm );
assertNotNull( legacyRealm.getResource( "/" + resource ) );
assertNotNull( legacyRealm.getResourceAsStream( "/" + resource ) );
assertTrue( legacyRealm.findResources( "/" + resource ).hasMoreElements() );
}
public void testFindResourceOnlyScansSelf()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "a.jar" ) );
ClassRealm childRealm = mainRealm.createChildRealm( "child" );
childRealm.addURL( getJarUrl( "b.jar" ) );
assertNotNull( childRealm.getResource( "a.properties" ) );
assertNotNull( childRealm.getResource( "b.properties" ) );
assertNull( childRealm.findResource( "a.properties" ) );
assertNotNull( childRealm.findResource( "b.properties" ) );
}
public void testFindResourcesOnlyScansSelf()
throws Exception
{
ClassRealm mainRealm = new ClassRealm( new ClassWorld(), "main", null );
mainRealm.addURL( getJarUrl( "a.jar" ) );
ClassRealm childRealm = mainRealm.createChildRealm( "child" );
childRealm.addURL( getJarUrl( "b.jar" ) );
assertTrue( childRealm.getResources( "a.properties" ).hasMoreElements() );
assertTrue( childRealm.getResources( "b.properties" ).hasMoreElements() );
assertFalse( childRealm.findResources( "a.properties" ).hasMoreElements() );
assertTrue( childRealm.findResources( "b.properties" ).hasMoreElements() );
}
/** Should never deadlock. Ever */
public void testParallelDeadlockClassRealm()
throws InterruptedException
{
for (int i = 0; i < 100; i++){
doOneDeadlockAttempt();
}
}
private void doOneDeadlockAttempt()
throws InterruptedException
{
// Deadlock sample graciously ripped from http://docs.oracle.com/javase/7/docs/technotes/guides/lang/cl-mt.html
final ClassRealm cl1 = new ClassRealm( new ClassWorld(), "cl1", null );
final ClassRealm cl2 = new ClassRealm( new ClassWorld(), "cl2", cl1 );
cl1.setParentRealm( cl2 );
cl1.addURL( getJarUrl( "deadlock.jar" ) );
cl2.addURL( getJarUrl( "deadlock.jar" ) );
final CountDownLatch latch = new CountDownLatch( 1 );
Runnable r1 = new Runnable()
{
public void run()
{
try
{
latch.await();
cl1.loadClass( "deadlock.A" );
}
catch ( ClassNotFoundException e )
{
throw new RuntimeException( e );
}
catch ( InterruptedException e )
{
throw new RuntimeException( e );
}
}
};
Runnable r2 = new Runnable()
{
public void run()
{
try
{
latch.await();
cl1.loadClass( "deadlock.C" );
}
catch ( ClassNotFoundException e )
{
throw new RuntimeException( e );
}
catch ( InterruptedException e )
{
throw new RuntimeException( e );
}
}
};
Thread thread = new Thread( r1 );
thread.start();
Thread thread1 = new Thread( r2 );
thread1.start();
latch.countDown();
thread.join();
thread1.join();
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
private Class loadClassOrNull( ClassRealm realm, String name )
{
try
{
return loadClass( realm, name );
}
catch ( ClassNotFoundException e )
{
return null;
}
}
private Class loadClass( ClassRealm realm, String name )
throws ClassNotFoundException
{
Class cls = realm.loadClass( name );
/*
* NOTE: Load the class both directly from the realm and indirectly from an (ordinary) child class loader which
* uses the specified class realm for parent delegation. The child class loader itself has no additional class
* path entries but relies entirely on the provided class realm. Hence, the created child class loader should in
* theory be able to load exactly the same classes/resources as the underlying class realm. In practice, it will
* test that class realms properly integrate into the standard Java class loader hierarchy.
*/
ClassLoader childLoader = new URLClassLoader( new URL[0], realm );
assertEquals( cls, childLoader.loadClass( name ) );
return cls;
}
private void getResource( ClassRealm realm, String name )
throws Exception
{
ClassLoader childLoader = new URLClassLoader( new URL[0], realm );
assertNotNull( realm.getResource( name ) );
assertEquals( realm.getResource( name ), childLoader.getResource( name ) );
assertEquals( Collections.list( realm.getResources( name ) ),
Collections.list( childLoader.getResources( name ) ) );
}
}
EntryTest.java 0000664 0000000 0000000 00000014304 12203204422 0036020 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/realm package org.codehaus.plexus.classworlds.realm;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.ClassWorld;
/**
* @author Ben Walding
*/
public class EntryTest
extends AbstractClassWorldsTestCase
{
/**
* Constructor for EntryTest.
*
* @param name
*/
public EntryTest( String name )
{
super( name );
}
public void testCompareTo()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry1 = new Entry( r, "org.test" );
Entry entry2 = new Entry( r, "org.test.impl" );
assertTrue( "org.test > org.test.impl", entry1.compareTo( entry2 ) > 0 );
}
/**
* Tests the equality is realm independant
*
* @throws Exception
*/
public void testEquals()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r1 = cw.newRealm( "test1" );
ClassRealm r2 = cw.newRealm( "test2" );
Entry entry1 = new Entry( r1, "org.test" );
Entry entry2 = new Entry( r2, "org.test" );
assertTrue( "entry1 == entry2", entry1.equals( entry2 ) );
assertTrue( "entry1.hashCode() == entry2.hashCode()", entry1.hashCode() == entry2.hashCode() );
}
public void testMatchesClassByPackageImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test" );
assertTrue( entry.matches( "org.test.MyClass" ) );
assertTrue( entry.matches( "org.test.MyClass$NestedClass" ) );
assertTrue( entry.matches( "org.test.MyClassUtils" ) );
assertTrue( entry.matches( "org.test.impl.MyClass" ) );
assertFalse( entry.matches( "org.tests.AnotherClass" ) );
}
public void testMatchesClassByClassImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test.MyClass" );
assertTrue( entry.matches( "org.test.MyClass" ) );
assertTrue( entry.matches( "org.test.MyClass$NestedClass" ) );
assertFalse( entry.matches( "org.test.MyClassUtils" ) );
assertFalse( entry.matches( "org.test.AnotherClass" ) );
}
public void testMatchesResourceByPackageImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test" );
assertTrue( entry.matches( "org/test/MyClass.class" ) );
assertTrue( entry.matches( "org/test/MyClass$NestedClass.class" ) );
assertTrue( entry.matches( "org/test/MyClasses.properties" ) );
assertTrue( entry.matches( "org/test/impl/MyClass.class" ) );
assertFalse( entry.matches( "org/tests/AnotherClass.class" ) );
}
public void testMatchesResourceByClassImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test.MyClass" );
assertTrue( entry.matches( "org/test/MyClass.class" ) );
assertTrue( entry.matches( "org/test/MyClass$NestedClass.class" ) );
assertFalse( entry.matches( "org/test/MyClass.properties" ) );
assertFalse( entry.matches( "org/test/AnotherClass" ) );
}
public void testMatchesAllImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "" );
assertTrue( entry.matches( "org.test.MyClass" ) );
assertTrue( entry.matches( "org.test.MyClass$NestedClass" ) );
assertTrue( entry.matches( "org/test/MyClass.class" ) );
assertTrue( entry.matches( "org/test/MyClass.properties" ) );
}
public void testMatchesResourceByResourceImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry1 = new Entry( r, "some.properties" );
assertTrue( entry1.matches( "some.properties" ) );
assertFalse( entry1.matches( "other.properties" ) );
Entry entry2 = new Entry( r, "org/test/some.properties" );
assertTrue( entry2.matches( "org/test/some.properties" ) );
assertFalse( entry2.matches( "org/test/other.properties" ) );
}
public void testMatchesClassByExactPackageImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test.*" );
assertTrue( entry.matches( "org.test.MyClass" ) );
assertTrue( entry.matches( "org.test.MyClass$NestedClass" ) );
assertTrue( entry.matches( "org.test.MyClassUtils" ) );
assertFalse( entry.matches( "org.test.impl.MyClass" ) );
assertFalse( entry.matches( "org.tests.AnotherClass" ) );
}
public void testMatchesResourceByExactPackageImport()
throws Exception
{
ClassWorld cw = new ClassWorld();
ClassRealm r = cw.newRealm( "test1" );
Entry entry = new Entry( r, "org.test.*" );
assertTrue( entry.matches( "org/test/MyClass.class" ) );
assertTrue( entry.matches( "org/test/MyClass$NestedClass.class" ) );
assertTrue( entry.matches( "org/test/MyClasses.properties" ) );
assertFalse( entry.matches( "org/test/impl/MyClass.class" ) );
assertFalse( entry.matches( "org/tests/AnotherClass.class" ) );
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/strategy/ 0000775 0000000 0000000 00000000000 12203204422 0034033 5 ustar 00root root 0000000 0000000 StrategyTest.java 0000664 0000000 0000000 00000007512 12203204422 0037266 0 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/java/org/codehaus/plexus/classworlds/strategy package org.codehaus.plexus.classworlds.strategy;
/*
* Copyright 2001-2006 Codehaus Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.InputStream;
import java.net.URL;
import java.util.Enumeration;
import org.codehaus.plexus.classworlds.AbstractClassWorldsTestCase;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
// jars within jars
// hierarchy vs graph
public class StrategyTest
extends AbstractClassWorldsTestCase
{
private ClassWorld world;
private ClassRealm realm;
private Strategy strategy;
public StrategyTest( String name )
{
super( name );
}
public void setUp()
throws Exception
{
this.world = new ClassWorld();
this.realm = this.world.newRealm( "realm" );
this.strategy = this.realm.getStrategy();
realm.addURL( getJarUrl( "component0-1.0.jar" ) );
}
public void testLoadingOfApplicationClass()
throws Exception
{
Class c = strategy.loadClass( "org.codehaus.plexus.Component0" );
assertNotNull( c );
}
public void testLoadingOfApplicationClassThenDoingItAgain()
throws Exception
{
Class c = strategy.loadClass( "org.codehaus.plexus.Component0" );
assertNotNull( c );
c = strategy.loadClass( "org.codehaus.plexus.Component0" );
assertNotNull( c );
}
public void testLoadingOfSystemClass()
throws Exception
{
Class c = strategy.getRealm().loadClass( "java.lang.Object" );
assertNotNull( c );
}
public void testLoadingOfNonExistentClass()
throws Exception
{
try
{
strategy.loadClass( "org.codehaus.plexus.NonExistentComponent" );
fail( "Should have thrown a ClassNotFoundException!" );
}
catch ( ClassNotFoundException e )
{
// do nothing
}
}
public void testGetApplicationResource()
throws Exception
{
URL resource = strategy.getResource( "META-INF/plexus/components.xml" );
assertNotNull( resource );
String content = getContent( resource.openStream() );
assertTrue( content.startsWith( "" ) );
}
public void testGetSystemResource()
throws Exception
{
URL resource = strategy.getRealm().getResource( "java/lang/Object.class" );
assertNotNull( resource );
}
public void testFindResources()
throws Exception
{
realm.addURL( getJarUrl( "component1-1.0.jar" ) );
Enumeration e = strategy.getResources( "META-INF/plexus/components.xml" );
assertNotNull( e );
int resourceCount = 0;
for ( Enumeration resources = e; resources.hasMoreElements(); )
{
resources.nextElement();
resourceCount++;
}
assertEquals( 2, resourceCount );
}
protected String getContent( InputStream in )
throws Exception
{
byte[] buffer = new byte[1024];
int read = 0;
StringBuffer content = new StringBuffer();
while ( ( read = in.read( buffer, 0, 1024 ) ) >= 0 )
{
content.append( new String( buffer, 0, read ) );
}
return content.toString();
}
}
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/ 0000775 0000000 0000000 00000000000 12203204422 0024674 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/a.jar 0000664 0000000 0000000 00000003060 12203204422 0025611 0 ustar 00root root 0000000 0000000 PK ܉; META-INF/ PK PK ܉; META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu +h)f&W+x%irr PK[G G PK
; a/PK #84 a/A.classmQJ1=c3 u5u1 uQjPҍ2I ~ %L UhpONιI> x8a`B ml`Ėm\2`Ȼ C2y @zj xJ~FG9f(ﴩ}0y<s5$ym6M&j 66:80Q2`{$xnľ4inf o#1HQݗq*"
xG4Am`>.{EBEz]r`z`u>!#, }f6U##Dՙ
-<;|\5&N(
V 2ePKF PK #84
a/Aa.classmQJAkķ16 xPAXTi8a 2=(x(g|@EWTW|~ haDTQc* ` P' icȜFP\LPS{\IL|'Ǥq۔\ 5< XpnS!Wn4Qq&-c@-l3XE=iACxүe$?8E@{
S2rh|L&DeMnujUgf=4'-S,P2sR6)r E{@@X"G` UN"S*>HM:#c%B
PK W O PK k70 a.propertiesKT((/H-*L- PK
PK ։; common.propertiesK+(/H-*L- PK
o PK ܉; META-INF/ PK ܉;[G G = META-INF/MANIFEST.MFPK
; a/PK #84F a/A.classPK #84 W O
c a/Aa.classPK k70
a.propertiesPK ։;
o 3 common.propertiesPK plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/a.properties 0000664 0000000 0000000 00000001277 12203204422 0027241 0 ustar 00root root 0000000 0000000 ################################################################################
#
# Copyright 2001-2006 The Codehaus Foundation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
a properties
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/b.jar 0000664 0000000 0000000 00000002574 12203204422 0025623 0 ustar 00root root 0000000 0000000 PK WZ; META-INF/ PK PK WZ; META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu +h)f&W+x%irr PK[G G PK
.Z; b/PK 4y5 b/B.classMNN0צ
v-Kխ0 PĐJL `Vp:IbBbQ0|ww~ 1 EKBx!X[Eڪf)(3?^jKHft'ߤ0b];mEZB"JYU3J,~zq>8L>p =" at v*1EVƐ_Sfb|>Y"ƘmW}Ƹ-PK'o ) PK 4y5
b/Bb.classENAN0mB[D"T)C 8٩\ rQpBxTźH`3Yo? LO0!4ih|OgR)MVIe) 1[), h)iVBIx)_+gyt<'$u6>8N'{HaVt`۟{#= HƄm1O=Sf? ?sK8cLv?PKg. - PK IZ; b.propertiesKMUUH+(/H-*L- PK~\ PK MZ; common.propertiesKMUUH+(/H-*L- PKa PK WZ; META-INF/ PK WZ;[G G = META-INF/MANIFEST.MFPK
.Z; b/PK 4y5'o ) b/B.classPK 4y5g. -
b/Bb.classPK IZ;~\ ) b.propertiesPK MZ;a x common.propertiesPK plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/b_old.jar 0000664 0000000 0000000 00000002311 12203204422 0026446 0 ustar 00root root 0000000 0000000 PK
$84 META-INF/PK #84 META-INF/MANIFEST.MFMLK-.
K-*ϳR03rCq,HLHU %MxRKRSt*AL
,u L4K|3+KRs<4yx PKf_ k PK
#84 b/PK #84 b/B.classQN0=BBwP)C+1E0IUHN
ńQk xsν?? DDZ7RoLyJ8TޭWq dsgR+z*b r h)eiUQ3B+䲪^J+11Ckv ["_LkʬF._'e8E ɜ@z]'ն}{ᨵa;`g+F`h9M,xdM8'ж3,
PK d4 PK #84
b/Bb.classP=K@~IV;`o蠐Ђ *up!&pIO8 U
r_ yuq\VW V0g"ah2Onu{e4E,PR?CZʒ4O9C WIL)UJi*1/E]8e\lQ t nHDDh0x["44+j'RNnF .Z%q4ki,EeFyj.E2pAKPڀKP3`Z/16k[h7PK:M!% PK
$84 A META-INF/PK #84f_ k ' META-INF/MANIFEST.MFPK
#84 A b/PK #84 d4 b/B.classPK #84:M!%
> b/Bb.classPK plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/c.jar 0000664 0000000 0000000 00000001322 12203204422 0025612 0 ustar 00root root 0000000 0000000 PK
$84 META-INF/PK #84 META-INF/MANIFEST.MFMLK-.
K-*ϳR03rCq,HLHU %MxRKRSt*AL
,u L4K|3+KRs<4yx PKf_ k PK
#84 c/PK #84 c/C.class-P T B&V
b[7\6{YI,<s19e2 GA m L B}00KLs,SvzQt'
4ʣ( Uȥ;+O*\0:vTd` dR8j5`5\ )*#jb6+9` ;7،V)PctԹ~\ b/PK
kc;jͩ A.classuNPƿv鱰 ª Dᒍqلd;[+6. O Ix ͡,F̜o~3pr+5 }Wb^7*B1ϓ025Pp[bzcu< g)^9Qh<96HOf13/b2wtG_ӡP$9_Ba"ȎqLy-B;) #ۧՉjWq vl ӘrPbuLb*@-h3 x% BP# SL^#q}w/l` /^?; kxa,+9 PK
kc;THe c B.class]NAN0$@K[y R)G'*RHy*xb3cp0g($A B0յn/y O<*B?YE07vH}֯6)$d !sE ,Y5dK&D+f2ri%Ez[,U>
BF #6qyJ蝮A n5p$!lt)=5?[LJoNPK
kc;N$* pom.xmlTn8 ?L "nEVq1V."g=4El%RKR!-&̛fL
6B $zܫ0r7 :
^&xag}nM 3 E(n*A%Ց })R8 uZ\u]BD 5r_(Ɋ
=]65*hn,~XaY= ʩM0;FQH4!#x;˳ >f?w+8-VU[x\Vr_s->plF;Qb7C}~*LlC[liɡTҭEu-Ay.B-_ <%aLJh3 xq?,oȫd.qv~q/'su54֭fqa $zܫ0r7 :
^&xag}nM 3 E(n*A%Ց })R8 uZ\u]BD 5r_(Ɋ
=]65*hn,~XaY= ʩM0;FQH4!#x;˳ >f?w+8-VU[x\Vr_s->plF;Qb7C}~*LlC[liɡTҭEu-Ay.B-_ <%aLJh3 xq?,oȫd.qv~q/'su54֭fqaP(?'.(]/9?%5#X 'H9ÔtdU%K2uIMK,)A6M9(Aă PK4h PK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0 $ org/codehaus/plexus/Component0.class;o>=vvVv6FҢT̜TF~܂ԼIJDFtԌb
P R\4$ PK2\ 7qɩDnE Dc}P(?'.(]/9?%5#X 'H9ÔtdU%K2uIMK,)A6M9(Aă PKOph PK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0 $ org/codehaus/plexus/Component1.class;o>=vvVv6FҢT̜TF~܂ԼCIJDFtԌb
P R\4$ PKǰpi y PK 0 + org/codehaus/plexus/DefaultComponent1.classm?`ƟSZd#1H0hb!&a R+Պe| J\%wy{~<QahdlB0tׄXo$:GW+ܱ:=9Qȭh'r0 m E|vNr!qv=H/"4_-d?gqX5R
zw- 9i3A
\3?PK
PK 0 META-INF/ PK 0LэJD D = META-INF/MANIFEST.MFPK
0 META-INF/plexus/PK 0Oph META-INF/plexus/components.xmlPK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0ǰpi y $ $ org/codehaus/plexus/Component1.classPK 0
+ org/codehaus/plexus/DefaultComponent1.classPK a plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/component2-1.0.jar 0000664 0000000 0000000 00000003163 12203204422 0027755 0 ustar 00root root 0000000 0000000 PK 0 META-INF/ PK PK 0 META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu )h)f&W+x%irr PKLэJD D PK
0 META-INF/plexus/PK 0 META-INF/plexus/components.xmlI-K+-N-RP>P(?'.(]/9?%5#X 'H9ÔtdU%K2uIMK,)A6M9(Aă PKh PK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0 $ org/codehaus/plexus/Component2.class;o>=vvVv6FҢT̜TF~܂Լ#IJDFtԌb
P R\4$ PKli y PK 0 + org/codehaus/plexus/DefaultComponent2.classm?`ƟSZd#1H0hb 1 z_V|-P@.ss
E % e 9 F&dz# ՙ<>2\ 7qɩDnE Dc}P(?'.(]/9?%5#X 'H9ÔtdU%K2uIMK,)A6M9(Aă PKh PK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0 $ org/codehaus/plexus/Component3.class;o>=vvVv6FҢT̜TF~܂ԼcIJDFtԌb
P R\4$ PKpi y PK 0 + org/codehaus/plexus/DefaultComponent3.classm?`ƟSZd#1H0` 1 z_V|-P@.ss
E % e 9 F&dz# ՙ<>2\ 7qɩDnE Dc}P(?'.(]/9?%5#X 'H9ÔtdU%K2uIMK,)A6M9(Aă PK5G h PK
0 org/PK
0
org/codehaus/PK
0 org/codehaus/plexus/PK 0 $ org/codehaus/plexus/Component4.class;o>=vvVv6FҢT̜TF~܂ԼIJDFtԌb
P R\4$ PK2\ 7qɩDnE Dc}H|P PKɦ\ PK
q: test/PK q: test/Component5.class;o>NvvvF̼F
MIJDļtD5#Wp~iQr[fN*#s~nA~^j^ H-P$D ! 0?)+5YX@,V PK9| PK [q: test/Component5.java+HLNLOU(I-.*(MLV+I-JKLNUp-K+1P ̼t Y⟓ 6 PK<
zL W PK q: test/DefaultComponent5.classeAO@ߴbL=J?PK6o PK q: META-INF/ PK q:[G G = META-INF/MANIFEST.MFPK
q: META-INF/plexus/PK q:ɦ\ META-INF/plexus/components.xmlPK
q: test/PK q:9| test/Component5.classPK [q:<
zL W ~ test/Component5.javaPK q:hr @ test/DefaultComponent5.classPK xq:6o ? test/DefaultComponent5.javaPK R plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/component5-2.0.jar 0000664 0000000 0000000 00000003536 12203204422 0027765 0 ustar 00root root 0000000 0000000 PK q: META-INF/ PK PK q: META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu +h)f&W+x%irr PK[G G PK
q: META-INF/plexus/PK q: META-INF/plexus/components.xmlI-K+-N-RP "PPQ~N]Ijq3LF ,
W[ I,σvIMK,)Aք j>H|P PKɦ\ PK
q: test/PK q: test/Component5.class;o>NvvvF̼rF
MIJDļtD5#Wp~iQr[fN*#s~nA~^j^ H-P$D ! 0?)+5YX@,V PKjm| PK q: test/Component5.java+HLNLOU(I-.*(MLV+I-JKLNUp-K+1P ̼t YZ 6 PK!
L W PK q: test/DefaultComponent5.classe1OAppwXGC%X( {8% 9oiebG.$$Ҽ7;>Zʨ{hx$Cm}"8ނP %LI8(M~'t{ګ0Vfά V`d_tMe %mbC~
e
@B>ּ=A#*YI\rE}9݊x )B-h#9NEE PKX @ PK q: test/DefaultComponent5.javaELA
0>G2+eqhxnK! 3;`I+8oYޤ e> $# C TN?_%:ځ ˂g?jRQr$nj]O
=PKCo PK q: META-INF/ PK q:[G G = META-INF/MANIFEST.MFPK
q: META-INF/plexus/PK q:ɦ\ META-INF/plexus/components.xmlPK
q: test/PK q:jm| test/Component5.classPK q:!
L W ~ test/Component5.javaPK q:X @ test/DefaultComponent5.classPK q:Co > test/DefaultComponent5.javaPK R plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/d.jar 0000664 0000000 0000000 00000001316 12203204422 0025616 0 ustar 00root root 0000000 0000000 PK
$84 META-INF/PK #84 META-INF/MANIFEST.MFMLK-.
K-*ϳR03rCq,HLHU %MxRKRSt*AL
,u L4K|3+KRs<4yx PKf_ k PK
#84 d/PK #84 d/D.class-=@ ?(ةZc"Zh{YXx e Йeߛo6<_ |x6ZY[p \ZZqDЗAPrs=Dz܋8d"QC: jFwŵLZ3s& 0w&^ȏ6NeRae5tl)ڬ@vm( PKD PK
$84 A META-INF/PK #84f_ k ' META-INF/MANIFEST.MFPK
#84 A d/PK #84D d/D.classPK plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/deadlock.jar 0000664 0000000 0000000 00000003050 12203204422 0027136 0 ustar 00root root 0000000 0000000 PK 8qC META-INF/ PK PK 8qC META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu *h%&*8% krr PKѕC D PK #qC deadlock/A.classM
PEK}YFЮZ$VҦp2UТ裢т;g`= :&& >W* p0, R)Ow"L(Y$@P/`qEGכ1X۬#V½A\
~Yb}U&skؕLR^ MR>oהPKpCrG PK #qC deadlock/B.classENP=uK# 5 jX[&UJb|Lr2xc@BB :`;HCEh{:QWV1+]/
d.O4> /T2'{^@-uQ$ҁ*[ Sn,#¿C`ܒ tQ@P]e PK=2½ PK #qC deadlock/C.classM
PZfAj.Me
WECE59gy 3mZYpBe\2q`y"@erS"YDR2X(TQՙ )4?gyUrjӃLZ}U&ؕ
)oBІݜwyPK I PK #qC deadlock/D.classENP=uK# 5!V
bpڤYI,|ӒIN漒y O ctlhZhYhT':`G0imO'ju9*J?f륁w2f~gJq ń`oK."b1U:0Qe $t
Íew~ =Tb[r:n|T`1R1: zL9 PK PK 8qC META-INF/ PK 8qCѕC D = META-INF/MANIFEST.MFPK #qCpCrG deadlock/A.classPK #qC=2½ deadlock/B.classPK #qC I deadlock/C.classPK #qC deadlock/D.classPK u plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/dupe-main.conf 0000664 0000000 0000000 00000000104 12203204422 0027415 0 ustar 00root root 0000000 0000000
main is com.werken.Foo from foo
main is com.werken.Bar from bar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/dupe-realm.conf 0000664 0000000 0000000 00000000074 12203204422 0027577 0 ustar 00root root 0000000 0000000
[cheese]
[dupe.realm]
[potatoes]
[dupe.realm]
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/early-import.conf 0000664 0000000 0000000 00000000040 12203204422 0030161 0 ustar 00root root 0000000 0000000
import org.xml.sax from root
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/inheritance.conf 0000664 0000000 0000000 00000001035 12203204422 0030033 0 ustar 00root root 0000000 0000000 # ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from root.maven
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[root]
load ${basedir}/src/test/test-data/a.jar
[root.maven]
load ${basedir}/src/test/test-data/b.jar
[root.maven.plugin]
load ${basedir}/src/test/test-data/c.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/launch-noclass.conf 0000664 0000000 0000000 00000000176 12203204422 0030461 0 ustar 00root root 0000000 0000000
main is b.Goober from app
[app]
load ${basedir}/src/test/test-data/a.jar
load ${basedir}/src/test/test-data/b.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/launch-nomethod.conf 0000664 0000000 0000000 00000000245 12203204422 0030631 0 ustar 00root root 0000000 0000000
main is c.C from app
[app]
load ${basedir}/src/test/test-data/a.jar
load ${basedir}/src/test/test-data/b.jar
load ${basedir}/src/test/test-data/c.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/nested.jar 0000664 0000000 0000000 00000003317 12203204422 0026660 0 ustar 00root root 0000000 0000000 PK
$84 META-INF/PK #84 META-INF/MANIFEST.MFMLK-.
K-*ϳR03rCq,HLHU %MxRKRSt*AL
,u L4K|3+KRs<4yx PKf_ k PK k70 nested.propertiesK-.IM+(/H-*L- PKl PK
#84 lib/PK #84 lib/a.jar ffb I& H}]C u=D8PM2_G?O7=_ϾgNx]:w +q*9ŨGb aZR>_z N5i,Rcܡb WobKbY'^k9 Le{ shok U
5Ǘ<,~6 Ǥ?e#nɂyVl<@B.>Խ|ށe9{\YmfJ}K_֫}_ۢաٍgpI{WrVh4[ Ků.
x&dt=Afτ\o9p8Ե{D^PJZv=f `E%?A&g?0
!r4A( $3;DC㔾I gLg@e$ H"! _$#4(T-ƖzT%'/Ktmȁȅ- 9"1r{Ìެl 6 d PK-y$ PK
$84 A META-INF/PK #84f_ k ' META-INF/MANIFEST.MFPK k70l nested.propertiesPK
#84 A lib/PK #84-y$ = lib/a.jarPK ! plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/nested.properties 0000664 0000000 0000000 00000001304 12203204422 0030272 0 ustar 00root root 0000000 0000000 ################################################################################
#
# Copyright 2001-2006 The Codehaus Foundation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
nested.properties
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/optionally-existent.conf 0000664 0000000 0000000 00000000661 12203204422 0031601 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from opt
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[opt]
optionally ${basedir}/target/test-lib/xml-apis-1.3.02.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/optionally-nonexistent.conf 0000664 0000000 0000000 00000000631 12203204422 0032311 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from opt
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[opt]
optionally /non/existant/path/*.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/realm-syntax.conf 0000664 0000000 0000000 00000000013 12203204422 0030161 0 ustar 00root root 0000000 0000000
[foo
]
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/resources/ 0000775 0000000 0000000 00000000000 12203204422 0026706 5 ustar 00root root 0000000 0000000 plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/resources/classworlds.conf 0000664 0000000 0000000 00000000630 12203204422 0032114 0 ustar 00root root 0000000 0000000 # ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is foo from root
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[root]
load ${basedir}/src/test/test-data/resources/werkflow.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/resources/werkflow.jar 0000664 0000000 0000000 00000012416 12203204422 0031250 0 ustar 00root root 0000000 0000000 PK
k5/ META-INF/PK k5/ META-INF/MANIFEST.MFuAn0E|#hi$PvY
$qƑc"
gl jzZ9SH
A| Ay dԬ?%V"
R_u@+,) L{C;ܷYG*N$&s 1 juҶ@϶ r$Ǐ4&]CLn AO1IE8@:RD|sfU-#)~ PKd PK
k5/ org/PK
k5/
org/codehaus/PK
k5/ org/codehaus/werkflow/PK
k5/ " org/codehaus/werkflow/personality/PK
k5/ ( org/codehaus/werkflow/personality/basic/PK
k5/ * org/codehaus/werkflow/personality/bpel4ws/PK
k5/ ) org/codehaus/werkflow/personality/common/PK k5/ 8 org/codehaus/werkflow/personality/basic/basic-syntax.xmlWn SXV/QiŸ!4;`:-/(L^]~!T7}B.^چq I\ 1B f!B]rh0V2
,:v\(EQbCrs .DJF*yG3Zv'W+}i
TFA#\E3_axִaa5Sx.0 _H"(Q/H0 [ZgHS/ 'L P YW^.b,Ve?t?Zi*Z U)j f3 #"f5m2FM8 J ?.H84@,&",&)bSZÇYL)ۮ ݆jEDKR5,qTgjO5$欢cLYa `*| 2;{|+ L:(|_ IC$MA6Un#
m#Ϟ(
GK3h̬q0c k=_ 7&\,z4|E nIxD\h dX[%QG? 7U. V?Zy).F-xƍtsu þ{ƍtsU(Z %akUzGl7n`O.&>wʮ1&@T .ܿSy2XE}3KGH6 څ
Gp?Epi4ԫ@ܶ>oЫq
K0ݻk }tP
VҡC;znP.aPK\8 PK k5/ < org/codehaus/werkflow/personality/bpel4ws/bpel4ws-syntax.xmlMn0F9E%Fl*EE;$ S@&&DHk~EٸT[Y{SR$sI
)mjO9TXNIW K+ro>ƋMX2 / - X.F- f7d"4QT((RjE@LJYP3l^93ۂ3cqu*Pf%/g ڜ ac V| Ø1qN-Z'B=oVrOFpY% 1H{p B~V
p4 9kLʼ]h~ZHuG:C
%mІj}j/LSecrN5EyAE١[pg|FOɞM?F,ߎH% ot}%DI U1Ţsgf
Vv~7]d;T]yáh+$l{BĿV^`_0EovmV
n\ ʖ;4 Ax9j+Ps} Ө9L{ Kw}V;Wi&!0*y>*":Ls?PKw;}] d PK T. META-INF/LICENSE.txtU]O8}ϯB#
-]}4qtc KiqasPu{ (1ٟ6|ф.'?Ǔ z5A-}
4k+4>#Vx\uGm6T
+
U756i++릧^se^/ʪjܵ
D OBzn운zguj6$UmԪWY)ZF?7#-uW7]W|1,ZjzKF٪` L@xP;m
|@զN<{M琂 *4=4]e^`ɴUp\V=bԛ̽p` '݇TMu1c$7Ʒ4p:anȆ6eVɳ2?V`= A.=(4Iu6nm z
R p9Xdend!ʩ\u'Nr@g#4>R 2@VyZ
SdEQ.$ϳ rL?EV0=1eR"E)ۘp d9q!Bq5GDowd=b&q`s"3a^+8AZ} G<&`cōLg^3 %#FMm 9a Z3U9&@CnHڏRD]LмPK x PK
k5/ A META-INF/PK k5/d ' META-INF/MANIFEST.MFPK
k5/ AR org/PK
k5/
At org/codehaus/PK
k5/ A org/codehaus/werkflow/PK
k5/ " A org/codehaus/werkflow/personality/PK
k5/ ( A org/codehaus/werkflow/personality/basic/PK
k5/ * AY org/codehaus/werkflow/personality/bpel4ws/PK
k5/ ) A org/codehaus/werkflow/personality/common/PK k5/\8 8 org/codehaus/werkflow/personality/basic/basic-syntax.xmlPK k5//E [ < org/codehaus/werkflow/personality/bpel4ws/bpel4ws-syntax.xmlPK k5/w;}] d 8 5 org/codehaus/werkflow/personality/common/core-idioms.xmlPK T.' 2 META-INF/LICENSE.txtPK k5/ x ` META-INF/INDEX.LISTPK 8 plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/set-using-existent.conf 0000664 0000000 0000000 00000001342 12203204422 0031322 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from opt
# ------------------------------------------------------------
# Set properties
# ------------------------------------------------------------
set set.using.existent using ${basedir}/src/test/test-data/set-using-existent.properties
set set.using.default using ${basedir}/src/test/test-data/set-using-existent.properties default testSet_Using_Existent_Default
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[opt]
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/set-using-existent.properties 0000664 0000000 0000000 00000001335 12203204422 0032573 0 ustar 00root root 0000000 0000000 ################################################################################
#
# Copyright 2001-2006 The Codehaus Foundation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
set.using.existent=testSet_Using_Existent
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/set-using-missing.conf 0000664 0000000 0000000 00000001175 12203204422 0031134 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from opt
# ------------------------------------------------------------
# Set properties
# ------------------------------------------------------------
set set.using.missing default testSet_Using_Missing_Default
set set.using.filtered.default default ${user.home}/m2
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[opt]
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/set-using-nonexistent.conf 0000664 0000000 0000000 00000001372 12203204422 0032040 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from opt
# ------------------------------------------------------------
# Set properties
# ------------------------------------------------------------
set set.using.nonexistent using ${basedir}/src/test/test-data/set-using-nonexistent.properties
set set.using.nonexistent.default using ${basedir}/src/test/test-data/set-using-nonexistent.properties default testSet_Using_NonExistent_Default
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[opt]
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/unhandled.conf 0000664 0000000 0000000 00000000007 12203204422 0027502 0 ustar 00root root 0000000 0000000
foo
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/valid-enh-launch-exitCode.conf 0000664 0000000 0000000 00000000172 12203204422 0032424 0 ustar 00root root 0000000 0000000
main is b.Bb from app
[app]
load ${basedir}/src/test/test-data/a.jar
load ${basedir}/src/test/test-data/b.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/valid-enh-launch.conf 0000664 0000000 0000000 00000000171 12203204422 0030661 0 ustar 00root root 0000000 0000000
main is b.B from app
[app]
load ${basedir}/src/test/test-data/a.jar
load ${basedir}/src/test/test-data/b.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/valid-launch-exitCode.conf 0000664 0000000 0000000 00000000116 12203204422 0031652 0 ustar 00root root 0000000 0000000
main is a.Aa from app
[app]
load ${basedir}/src/test/test-data/a.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/valid-launch.conf 0000664 0000000 0000000 00000000115 12203204422 0030107 0 ustar 00root root 0000000 0000000
main is a.A from app
[app]
load ${basedir}/src/test/test-data/a.jar
plexus-classworlds-plexus-classworlds-2.5.1/src/test/test-data/valid.conf 0000664 0000000 0000000 00000001241 12203204422 0026640 0 ustar 00root root 0000000 0000000
# ------------------------------------------------------------
# Define the main entry-point
# ------------------------------------------------------------
main is org.apache.maven.app.App from maven
# ------------------------------------------------------------
# Start defining realms
# ------------------------------------------------------------
[xml]
load ${basedir}/target/test-lib/xml-apis-1.3.02.jar
[ant]
import org.xml.sax from xml
load ${basedir}/target/test-lib/ant-1.9.0.jar
[maven]
import org.xml.sax from xml
load ${basedir}/target/test-lib/commons-logging-1.0.3.jar
[glob]
load ${basedir}/src/test/test-data/*.jar