Siphalor/tweed5-commons-logging
1
0
Fork 0
Code Activity

Remove trailing whitespace.

Browse Source
This commit is contained in:
Gary Gregory
2020-06-17 11:11:30 -04:00
parent d909c8c415
commit 45f1d58bee
17 changed files with 158 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/test/java/org/apache/commons/logging/AltHashtable.java
View File

@@ -25,7 +25,7 @@ public class AltHashtable extends Hashtable {
* Generated serial version ID.
*/
private static final long serialVersionUID = 8927996458633688095L;
public static Object lastKey;
public static Object lastValue;

88
src/test/java/org/apache/commons/logging/LoadTestCase.java
View File

@@ -27,7 +27,7 @@ public class LoadTestCase extends TestCase{
//TODO: need some way to add service provider packages
static private String LOG_PCKG[] = {"org.apache.commons.logging",
"org.apache.commons.logging.impl"};
/**
* A custom classloader which "duplicates" logging classes available
* in the parent classloader into itself.
@@ -38,51 +38,51 @@ public class LoadTestCase extends TestCase{
* as the classloader that loaded it.
*/
static class AppClassLoader extends ClassLoader{
java.util.Map classes = new java.util.HashMap();
AppClassLoader(ClassLoader parent){
super(parent);
}
private Class def(String name)throws ClassNotFoundException{
Class result = (Class)classes.get(name);
if(result != null){
return result;
}
try{
ClassLoader cl = this.getClass().getClassLoader();
String classFileName = name.replace('.','/') + ".class";
java.io.InputStream is = cl.getResourceAsStream(classFileName);
java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
while(is.available() > 0){
out.write(is.read());
}
byte data [] = out.toByteArray();
result = super.defineClass(name, data, 0, data.length );
classes.put(name,result);
return result;
}catch(java.io.IOException ioe){
throw new ClassNotFoundException( name + " caused by "
+ ioe.getMessage() );
}
}
// not very trivial to emulate we must implement "findClass",
// but it will delegete to junit class loder first
public Class loadClass(String name)throws ClassNotFoundException{
//isolates all logging classes, application in the same classloader too.
//filters exeptions to simlify handling in test
for(int i = 0; i < LOG_PCKG.length; i++ ){
@@ -93,9 +93,9 @@ public class LoadTestCase extends TestCase{
}
return super.loadClass(name);
}
}
/**
* Call the static setAllowFlawedContext method on the specified class
@@ -116,26 +116,26 @@ public class LoadTestCase extends TestCase{
* are available via the system classpath.
*/
public void testInContainer()throws Exception{
//problem can be in this step (broken app container or missconfiguration)
//1. Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
//2. Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
// we expect this :
// 1. Thread.currentThread().setContextClassLoader(appLoader);
// 2. Thread.currentThread().setContextClassLoader(null);
// Context classloader is same as class calling into log
Class cls = reload();
Thread.currentThread().setContextClassLoader(cls.getClassLoader());
execute(cls);
// Context classloader is the "bootclassloader". This is technically
// bad, but LogFactoryImpl.ALLOW_FLAWED_CONTEXT defaults to true so
// this test should pass.
cls = reload();
Thread.currentThread().setContextClassLoader(null);
execute(cls);
// Context classloader is the "bootclassloader". This is same as above
// except that ALLOW_FLAWED_CONTEXT is set to false; an error should
// now be reported.
@@ -148,7 +148,7 @@ public class LoadTestCase extends TestCase{
} catch(LogConfigurationException ex) {
// expected; the boot classloader doesn't *have* JCL available
}
// Context classloader is the system classloader.
//
// This is expected to cause problems, as LogFactoryImpl will attempt
@@ -159,9 +159,9 @@ public class LoadTestCase extends TestCase{
cls = reload();
Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
execute(cls);
// Context classloader is the system classloader. This is the same
// as above except that ALLOW_FLAWED_CONTEXT is set to false; an error
// as above except that ALLOW_FLAWED_CONTEXT is set to false; an error
// should now be reported.
cls = reload();
Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
@@ -171,7 +171,7 @@ public class LoadTestCase extends TestCase{
fail("Error: somehow downcast a Logger loaded via system classloader"
+ " to the Log interface loaded via a custom classloader");
} catch(LogConfigurationException ex) {
// expected
// expected
}
}
@@ -180,46 +180,46 @@ public class LoadTestCase extends TestCase{
* the classloader used to load this test class.
*/
private Class reload()throws Exception{
Class testObjCls = null;
AppClassLoader appLoader = new AppClassLoader(
AppClassLoader appLoader = new AppClassLoader(
this.getClass().getClassLoader());
try{
testObjCls = appLoader.loadClass(UserClass.class.getName());
}catch(ClassNotFoundException cnfe){
throw cnfe;
}catch(Throwable t){
t.printStackTrace();
fail("AppClassLoader failed ");
}
assertTrue( "app isolated" ,testObjCls.getClassLoader() == appLoader );
return testObjCls;
}
private void execute(Class cls)throws Exception{
cls.newInstance();
}
public void setUp() {
// save state before test starts so we can restore it when test ends
origContextClassLoader = Thread.currentThread().getContextClassLoader();
}
public void tearDown() {
// restore original state so a test can't stuff up later tests.
Thread.currentThread().setContextClassLoader(origContextClassLoader);
}
private ClassLoader origContextClassLoader;
}

4
src/test/java/org/apache/commons/logging/NullClassLoaderTestCase.java
View File

@@ -26,8 +26,8 @@ import junit.framework.TestCase;
*/
public class NullClassLoaderTestCase extends TestCase {
//---------------------- unit tests ---------------------------------
//---------------------- unit tests ---------------------------------
/**
* This tests that when getContextClassLoader returns null, the
* LogFactory.getLog(name) method still correctly returns the same

58
src/test/java/org/apache/commons/logging/PathableClassLoader.java
View File

@@ -48,9 +48,9 @@ import java.util.Map;
*/
public class PathableClassLoader extends URLClassLoader {
private static final URL[] NO_URLS = new URL[0];
/**
* A map of package-prefix to ClassLoader. Any class which is in
* this map is looked up via the specified classloader instead of
@@ -60,7 +60,7 @@ public class PathableClassLoader extends URLClassLoader {
* with classes loaded via a custom classloader. As an example, junit
* testcases which are loaded via a custom classloader needs to see
* the same junit classes as the code invoking the testcase, otherwise
* they can't pass result objects back.
* they can't pass result objects back.
* <p>
* Normally, only a classloader created with a null parent needs to
* have any lookasides defined.
@@ -96,7 +96,7 @@ public class PathableClassLoader extends URLClassLoader {
public PathableClassLoader(ClassLoader parent) {
super(NO_URLS, parent);
}
/**
* Allow caller to explicitly add paths. Generally this not a good idea;
* use addLogicalLib instead, then define the location for that logical
@@ -110,9 +110,9 @@ public class PathableClassLoader extends URLClassLoader {
* Specify whether this classloader should ask the parent classloader
* to resolve a class first, before trying to resolve it via its own
* classpath.
* <p>
* <p>
* Checking with the parent first is the normal approach for java, but
* components within containers such as servlet engines can use
* components within containers such as servlet engines can use
* child-first lookup instead, to allow the components to override libs
* which are visible in shared classloaders provided by the container.
* <p>
@@ -140,7 +140,7 @@ public class PathableClassLoader extends URLClassLoader {
*/
public void useSystemLoader(String prefix) {
useExplicitLoader(prefix, ClassLoader.getSystemClassLoader());
}
/**
@@ -148,7 +148,7 @@ public class PathableClassLoader extends URLClassLoader {
* <p>
* The specified classloader is normally a loader that is NOT
* an ancestor of this classloader. In particular, this loader
* may have the bootloader as its parent, but be configured to
* may have the bootloader as its parent, but be configured to
* see specific other classes (eg the junit library loaded
* via the system classloader).
* <p>
@@ -186,7 +186,7 @@ public class PathableClassLoader extends URLClassLoader {
/**
* Specify a logical library to be included in the classpath used to
* locate classes.
* locate classes.
* <p>
* The specified lib name is used as a key into the system properties;
* there is expected to be a system property defined with that name
@@ -198,11 +198,11 @@ public class PathableClassLoader extends URLClassLoader {
* this class is a URLClassLoader then the set of URLs that the
* classloader uses for its classpath is scanned; any jar in the
* URL set whose name starts with the specified string is added to
* the classpath managed by this instance.
* the classpath managed by this instance.
* <p>
* Using logical library names allows the calling code to specify its
* desired classpath without knowing the exact location of the necessary
* classes.
* classes.
*/
public void addLogicalLib(String logicalLib) {
// first, check the system properties
@@ -255,14 +255,14 @@ public class PathableClassLoader extends URLClassLoader {
if (cl instanceof URLClassLoader == false) {
return null;
}
URLClassLoader ucl = (URLClassLoader) cl;
URL[] path = ucl.getURLs();
URL shortestMatch = null;
int shortestMatchLen = Integer.MAX_VALUE;
for(int i=0; i<path.length; ++i) {
URL u = path[i];
// extract the filename bit on the end of the url
String filename = u.toString();
if (!filename.endsWith(".jar")) {
@@ -274,7 +274,7 @@ public class PathableClassLoader extends URLClassLoader {
if (lastSlash >= 0) {
filename = filename.substring(lastSlash+1);
}
if (filename.startsWith(logicalLib)) {
// ok, this is a candidate
if (filename.length() < shortestMatchLen) {
@@ -283,18 +283,18 @@ public class PathableClassLoader extends URLClassLoader {
}
}
}
return shortestMatch;
}
/**
* Override ClassLoader method.
* <p>
* For each explicitly mapped package prefix, if the name matches the
* prefix associated with that entry then attempt to load the class via
* For each explicitly mapped package prefix, if the name matches the
* prefix associated with that entry then attempt to load the class via
* that entries' classloader.
*/
protected Class loadClass(String name, boolean resolve)
protected Class loadClass(String name, boolean resolve)
throws ClassNotFoundException {
// just for performance, check java and javax
if (name.startsWith("java.") || name.startsWith("javax.")) {
@@ -312,17 +312,17 @@ public class PathableClassLoader extends URLClassLoader {
}
}
}
if (parentFirst) {
return super.loadClass(name, resolve);
} else {
// Implement child-first.
// Implement child-first.
//
// It appears that the findClass method doesn't check whether the
// class has already been loaded. This seems odd to me, but without
// first checking via findLoadedClass we can get java.lang.LinkageError
// with message "duplicate class definition" which isn't good.
try {
Class clazz = findLoadedClass(name);
if (clazz == null) {
@@ -337,7 +337,7 @@ public class PathableClassLoader extends URLClassLoader {
}
}
}
/**
* Same as parent class method except that when parentFirst is false
* the resource is looked for in the local classpath before the parent
@@ -354,7 +354,7 @@ public class PathableClassLoader extends URLClassLoader {
return super.getResource(name);
}
}
/**
* Emulate a proper implementation of getResources which respects the
* setting for parentFirst.
@@ -368,7 +368,7 @@ public class PathableClassLoader extends URLClassLoader {
return super.getResources(name);
} else {
Enumeration localUrls = super.findResources(name);
ClassLoader parent = getParent();
if (parent == null) {
// Alas, there is no method to get matching resources
@@ -391,11 +391,11 @@ public class PathableClassLoader extends URLClassLoader {
return Collections.enumeration(localItems);
}
}
/**
*
* Clean implementation of list function of
* {@link java.utils.Collection} added in JDK 1.4
*
* Clean implementation of list function of
* {@link java.utils.Collection} added in JDK 1.4
* @param en <code>Enumeration</code>, possibly null
* @return <code>ArrayList</code> containing the enumerated
* elements in the enumerated order, not null
@@ -410,7 +410,7 @@ public class PathableClassLoader extends URLClassLoader {
}
return results;
}
/**
* Same as parent class method except that when parentFirst is false
* the resource is looked for in the local classpath before the parent

22
src/test/java/org/apache/commons/logging/PathableTestSuite.java
View File

@@ -33,24 +33,24 @@ import junit.framework.TestSuite;
* public static Test suite() throws Exception {
* PathableClassLoader parent = new PathableClassLoader(null);
* parent.useSystemLoader("junit.");
*
*
* PathableClassLoader child = new PathableClassLoader(parent);
* child.addLogicalLib("testclasses");
* child.addLogicalLib("log4j12");
* child.addLogicalLib("commons-logging");
*
*
* Class testClass = child.loadClass(SomeTestCase.class.getName());
* ClassLoader contextClassLoader = child;
*
*
* PathableTestSuite suite = new PathableTestSuite(testClass, child);
* return suite;
* }
*
*
* // test methods go here
* }
* </pre>
* Note that if the suite method throws an exception then this will be handled
* reasonable gracefully by junit; it will report that the suite method for
* reasonable gracefully by junit; it will report that the suite method for
* a test case failed with exception yyy.
* <p>
* The use of PathableClassLoader is not required to use this class, but it
@@ -59,7 +59,7 @@ import junit.framework.TestSuite;
* This class will run each test methods within the specified TestCase using
* the specified context classloader and system classloader. If different
* tests within the same class require different context classloaders,
* then the context classloader passed to the constructor should be the
* then the context classloader passed to the constructor should be the
* "lowest" one available, and tests that need the context set to some parent
* of this "lowest" classloader can call
* <pre>
@@ -70,14 +70,14 @@ import junit.framework.TestSuite;
* is undone after the test is run, so tests don't need to worry about
* restoring the context classloader on exit. This class also ensures that
* the system properties are restored to their original settings after each
* test, so tests that manipulate those don't need to worry about resetting them.
* test, so tests that manipulate those don't need to worry about resetting them.
* <p>
* This class does not provide facilities for manipulating system properties;
* tests that need specific system properties can simply set them in the
* fixture or at the start of a test method.
* <p>
* <b>Important!</b> When the test case is run, "this.getClass()" refers of
* course to the Class object passed to the constructor of this class - which
* course to the Class object passed to the constructor of this class - which
* is different from the class whose suite() method was executed to determine
* the classpath. This means that the suite method cannot communicate with
* the test cases simply by setting static variables (for example to make the
@@ -87,7 +87,7 @@ import junit.framework.TestSuite;
* <p>
* <h2>Limitations</h2>
* <p>
* This class cannot control the system classloader (ie what method
* This class cannot control the system classloader (ie what method
* ClassLoader.getSystemClassLoader returns) because Java provides no
* mechanism for setting the system classloader. In this case, the only
* option is to invoke the unit test in a separate JVM with the appropriate
@@ -112,10 +112,10 @@ public class PathableTestSuite extends TestSuite {
/**
* Constructor.
*
*
* @param testClass is the TestCase that is to be run, as loaded by
* the appropriate ClassLoader.
*
*
* @param contextClassLoader is the loader that should be returned by
* calls to Thread.currentThread.getContextClassLoader from test methods
* (or any method called by test methods).

60
src/test/java/org/apache/commons/logging/pathable/ParentFirstTestCase.java
View File

@@ -65,28 +65,28 @@ public class ParentFirstTestCase extends TestCase {
// this class, so use that as the source for future access to classes
// from the junit package.
parent.useExplicitLoader("junit.", thisClassLoader);
// make the commons-logging.jar classes visible via the parent
parent.addLogicalLib("commons-logging");
// create a child classloader to load the test case through
PathableClassLoader child = new PathableClassLoader(parent);
// obviously, the child classloader needs to have the test classes
// in its path!
child.addLogicalLib("testclasses");
child.addLogicalLib("commons-logging-adapters");
// create a third classloader to be the context classloader.
PathableClassLoader context = new PathableClassLoader(child);
// reload this class via the child classloader
Class testClass = child.loadClass(thisClass.getName());
// and return our custom TestSuite class
return new PathableTestSuite(testClass, context);
}
/**
* Utility method to return the set of all classloaders in the
* parent chain starting from the one that loaded the class for
@@ -115,14 +115,14 @@ public class ParentFirstTestCase extends TestCase {
assertEquals("Context classloader has unexpected type",
PathableClassLoader.class.getName(),
contextLoader.getClass().getName());
// the classloader that loaded this class is obviously not null
ClassLoader thisLoader = this.getClass().getClassLoader();
assertNotNull("thisLoader is null", thisLoader);
assertEquals("thisLoader has unexpected type",
PathableClassLoader.class.getName(),
thisLoader.getClass().getName());
// the suite method specified that the context classloader's parent
// is the loader that loaded this test case.
assertSame("Context classloader is not child of thisLoader",
@@ -134,7 +134,7 @@ public class ParentFirstTestCase extends TestCase {
assertEquals("Parent classloader has unexpected type",
PathableClassLoader.class.getName(),
parentLoader.getClass().getName());
// parent should have a parent of null
assertNull("Parent classloader has non-null parent", parentLoader.getParent());
@@ -152,7 +152,7 @@ public class ParentFirstTestCase extends TestCase {
// though it is accessable due to trickery in the PathableClassLoader.
Class junitTest = contextLoader.loadClass("junit.framework.Test");
Set ancestorCLs = getAncestorCLs();
assertFalse("Junit not loaded by ancestor classloader",
assertFalse("Junit not loaded by ancestor classloader",
ancestorCLs.contains(junitTest.getClassLoader()));
// jcl api classes should be visible only via the parent
@@ -163,14 +163,14 @@ public class ParentFirstTestCase extends TestCase {
// jcl adapter classes should be visible via both parent and child. However
// as the classloaders are parent-first we should see the parent one.
Class log4jClass = contextLoader.loadClass("org.apache.commons.logging.impl.Log4JLogger");
assertSame("Log4JLogger not loaded via parent",
assertSame("Log4JLogger not loaded via parent",
log4jClass.getClassLoader(), parentLoader);
// test classes should be visible via the child only
Class testClass = contextLoader.loadClass("org.apache.commons.logging.PathableTestSuite");
assertSame("PathableTestSuite not loaded via child",
assertSame("PathableTestSuite not loaded via child",
testClass.getClassLoader(), thisLoader);
// test loading of class that is not available
try {
Class noSuchClass = contextLoader.loadClass("no.such.class");
@@ -185,16 +185,16 @@ public class ParentFirstTestCase extends TestCase {
assertNull("String class classloader is not null!",
stringClass.getClassLoader());
}
/**
* Test that the various flavours of ClassLoader.getResource work as expected.
*/
public void testResource() {
URL resource;
ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
ClassLoader childLoader = contextLoader.getParent();
// getResource where it doesn't exist
resource = childLoader.getResource("nosuchfile");
assertNull("Non-null URL returned for invalid resource name", resource);
@@ -202,7 +202,7 @@ public class ParentFirstTestCase extends TestCase {
// getResource where it is accessable only to parent classloader
resource = childLoader.getResource("org/apache/commons/logging/Log.class");
assertNotNull("Unable to locate Log.class resource", resource);
// getResource where it is accessable only to child classloader
resource = childLoader.getResource("org/apache/commons/logging/PathableTestSuite.class");
assertNotNull("Unable to locate PathableTestSuite.class resource", resource);
@@ -216,42 +216,42 @@ public class ParentFirstTestCase extends TestCase {
assertTrue("Incorrect source for Log4JLogger class",
resource.toString().indexOf("/commons-logging-1.") > 0);
}
/**
* Test that the various flavours of ClassLoader.getResources work as expected.
*/
public void testResources() throws Exception {
Enumeration resources;
URL[] urls;
// verify the classloader hierarchy
ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
ClassLoader childLoader = contextLoader.getParent();
ClassLoader parentLoader = childLoader.getParent();
ClassLoader bootLoader = parentLoader.getParent();
assertNull("Unexpected classloader hierarchy", bootLoader);
// getResources where no instances exist
resources = childLoader.getResources("nosuchfile");
urls = toURLArray(resources);
assertEquals("Non-null URL returned for invalid resource name", 0, urls.length);
// getResources where the resource only exists in the parent
resources = childLoader.getResources("org/apache/commons/logging/Log.class");
urls = toURLArray(resources);
assertEquals("Unexpected number of Log.class resources found", 1, urls.length);
// getResources where the resource only exists in the child
resources = childLoader.getResources("org/apache/commons/logging/PathableTestSuite.class");
urls = toURLArray(resources);
assertEquals("Unexpected number of PathableTestSuite.class resources found", 1, urls.length);
// getResources where the resource exists in both.
// resources should be returned in order (parent-resource, child-resource)
resources = childLoader.getResources("org/apache/commons/logging/impl/Log4JLogger.class");
urls = toURLArray(resources);
assertEquals("Unexpected number of Log4JLogger.class resources found", 2, urls.length);
// There is no gaurantee about the ordering of results returned from getResources
// To make this test portable across JVMs, sort the string to give them a known order
String[] urlsToStrings = new String[2];
@@ -262,7 +262,7 @@ public class ParentFirstTestCase extends TestCase {
urlsToStrings[0].indexOf("/commons-logging-1.") > 0);
assertTrue("Incorrect source for Log4JLogger class",
urlsToStrings[1].indexOf("/commons-logging-adapters-1.") > 0);
}
/**
@@ -283,23 +283,23 @@ public class ParentFirstTestCase extends TestCase {
*/
public void testResourceAsStream() throws Exception {
java.io.InputStream is;
// verify the classloader hierarchy
ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
ClassLoader childLoader = contextLoader.getParent();
ClassLoader parentLoader = childLoader.getParent();
ClassLoader bootLoader = parentLoader.getParent();
assertNull("Unexpected classloader hierarchy", bootLoader);
// getResourceAsStream where no instances exist
is = childLoader.getResourceAsStream("nosuchfile");
assertNull("Invalid resource returned non-null stream", is);
// getResourceAsStream where resource does exist
is = childLoader.getResourceAsStream("org/apache/commons/logging/Log.class");
assertNotNull("Null returned for valid resource", is);
is.close();
// It would be nice to test parent-first ordering here, but that would require
// having a resource with the same name in both the parent and child loaders,
// but with different contents. That's a little tricky to set up so we'll

2
src/test/java/org/apache/commons/logging/security/MockSecurityManager.java
View File

@@ -101,7 +101,7 @@ public class MockSecurityManager extends SecurityManager {
// requiring RuntimePermission: "accessClassInPackage.sun.util.logging.resources"
return;
}
if (cname.equals("java.security.AccessController")) {
// Presumably method name equals "doPrivileged"
//

6
src/test/java/org/apache/commons/logging/security/SecurityForbiddenTestCase.java
View File

@@ -76,11 +76,11 @@ public class SecurityForbiddenTestCase extends TestCase
public void setUp() {
// save security manager so it can be restored in tearDown
oldSecMgr = System.getSecurityManager();
PathableClassLoader classLoader = new PathableClassLoader(null);
classLoader.addLogicalLib("commons-logging");
classLoader.addLogicalLib("testclasses");
otherClassLoader = classLoader;
}
@@ -142,7 +142,7 @@ public class SecurityForbiddenTestCase extends TestCase
/**
* Test what happens when JCL is run with absolutely no security
* privileges at all and a class loaded with a different classloader
* than the context classloader of the current thread tries to log something.
* than the context classloader of the current thread tries to log something.
*/
public void testContextClassLoader() {
System.setProperty(

8
src/test/java/org/apache/commons/logging/simple/CustomConfigTestCase.java
View File

@@ -113,7 +113,7 @@ public class CustomConfigTestCase extends DefaultConfigTestCase {
loader.useExplicitLoader("junit.", Test.class.getClassLoader());
loader.addLogicalLib("testclasses");
loader.addLogicalLib("commons-logging");
Class testClass = loader.loadClass(thisClass.getName());
return new PathableTestSuite(testClass, loader);
}
@@ -192,18 +192,18 @@ public class CustomConfigTestCase extends DefaultConfigTestCase {
assertTrue(((DecoratedSimpleLog) log).getShowShortName());
}
/** Hook for subclassses */
protected void checkShowDateTime() {
assertTrue(!((DecoratedSimpleLog) log).getShowDateTime());
}
/** Hook for subclasses */
protected void checkDecoratedDateTime() {
assertEquals("yyyy/MM/dd HH:mm:ss:SSS zzz",
((DecoratedSimpleLog) log).getDateTimeFormat());
}
// Check the actual log records against the expected ones

2
src/test/java/org/apache/commons/logging/simple/DefaultConfigTestCase.java
View File

@@ -81,7 +81,7 @@ public class DefaultConfigTestCase extends TestCase {
loader.useExplicitLoader("junit.", Test.class.getClassLoader());
loader.addLogicalLib("testclasses");
loader.addLogicalLib("commons-logging");
Class testClass = loader.loadClass(thisClass.getName());
return new PathableTestSuite(testClass, loader);
}

2
src/test/java/org/apache/commons/logging/simple/LogRecord.java
View File

@@ -29,7 +29,7 @@ public class LogRecord implements Serializable {
* Generated serial version ID.
*/
private static final long serialVersionUID = -5254831759209770665L;
public LogRecord(int type, Object message, Throwable t) {
this.type = type;
this.message = message;

2
src/test/java/org/apache/commons/logging/tccl/BadTCCLTestCase.java
View File

@@ -37,7 +37,7 @@ public class BadTCCLTestCase extends TestCase {
}
// test methods
/**
* This test just tests that a log implementation can be found
* by the LogFactory.

2
src/test/java/org/apache/commons/logging/tccl/NullTCCLTestCase.java
View File

@@ -34,7 +34,7 @@ public class NullTCCLTestCase extends TestCase {
}
// test methods
/**
* This test just tests that a log implementation can be found
* by the LogFactory.

14
src/test/java/org/apache/commons/logging/tccl/log/TcclDisabledTestCase.java
View File

@@ -36,7 +36,7 @@ import org.apache.commons.logging.PathableTestSuite;
public class TcclDisabledTestCase extends TestCase {
public static final String MY_LOG_PKG =
public static final String MY_LOG_PKG =
"org.apache.commons.logging.tccl.custom";
public static final String MY_LOG_IMPL =
@@ -58,7 +58,7 @@ public class TcclDisabledTestCase extends TestCase {
dummy.useExplicitLoader("junit.", Test.class.getClassLoader());
dummy.addLogicalLib("testclasses");
dummy.addLogicalLib("commons-logging");
String thisClassPath = thisClass.getName().replace('.', '/') + ".class";
URL baseUrl = dummy.findResource(thisClassPath);
@@ -69,7 +69,7 @@ public class TcclDisabledTestCase extends TestCase {
// Log class. Therefore if that class can be found, then the
// TCCL must have been used to load it.
PathableClassLoader emptyLoader = new PathableClassLoader(null);
PathableClassLoader parentLoader = new PathableClassLoader(null);
parentLoader.useExplicitLoader("junit.", Test.class.getClassLoader());
parentLoader.addLogicalLib("commons-logging");
@@ -77,7 +77,7 @@ public class TcclDisabledTestCase extends TestCase {
// hack to ensure that the testcase classloader can't see
// the custom MyLog
parentLoader.useExplicitLoader(MY_LOG_PKG + ".", emptyLoader);
URL propsEnableUrl = new URL(baseUrl, "props_disable_tccl/");
parentLoader.addURL(propsEnableUrl);
@@ -108,7 +108,7 @@ public class TcclDisabledTestCase extends TestCase {
* Verify that MyLog is only loadable via the tccl.
*/
public void testLoader() throws Exception {
ClassLoader thisClassLoader = this.getClass().getClassLoader();
ClassLoader tcclLoader = Thread.currentThread().getContextClassLoader();
@@ -123,7 +123,7 @@ public class TcclDisabledTestCase extends TestCase {
} catch(ClassNotFoundException ex) {
// ok, expected
}
// MyLog should be loadable via tccl loader
try {
Class clazz = tcclLoader.loadClass(MY_LOG_IMPL);
@@ -142,7 +142,7 @@ public class TcclDisabledTestCase extends TestCase {
public void testTcclLoading() throws Exception {
LogFactory instance = LogFactory.getFactory();
assertEquals(
"Correct LogFactory loaded",
"Correct LogFactory loaded",
"org.apache.commons.logging.impl.LogFactoryImpl",
instance.getClass().getName());

18
src/test/java/org/apache/commons/logging/tccl/log/TcclEnabledTestCase.java
View File

@@ -36,7 +36,7 @@ import org.apache.commons.logging.PathableTestSuite;
public class TcclEnabledTestCase extends TestCase {
public static final String MY_LOG_PKG =
public static final String MY_LOG_PKG =
"org.apache.commons.logging.tccl.custom";
public static final String MY_LOG_IMPL =
@@ -58,7 +58,7 @@ public class TcclEnabledTestCase extends TestCase {
dummy.useExplicitLoader("junit.", Test.class.getClassLoader());
dummy.addLogicalLib("testclasses");
dummy.addLogicalLib("commons-logging");
String thisClassPath = thisClass.getName().replace('.', '/') + ".class";
URL baseUrl = dummy.findResource(thisClassPath);
@@ -69,7 +69,7 @@ public class TcclEnabledTestCase extends TestCase {
// Log class. Therefore if that class can be found, then the
// TCCL must have been used to load it.
PathableClassLoader emptyLoader = new PathableClassLoader(null);
PathableClassLoader parentLoader = new PathableClassLoader(null);
parentLoader.useExplicitLoader("junit.", Test.class.getClassLoader());
parentLoader.addLogicalLib("commons-logging");
@@ -77,7 +77,7 @@ public class TcclEnabledTestCase extends TestCase {
// hack to ensure that the testcase classloader can't see
// the custom MyLogFactoryImpl
parentLoader.useExplicitLoader(MY_LOG_PKG + ".", emptyLoader);
URL propsEnableUrl = new URL(baseUrl, "props_enable_tccl/");
parentLoader.addURL(propsEnableUrl);
@@ -108,10 +108,10 @@ public class TcclEnabledTestCase extends TestCase {
* Verify that MyLogFactoryImpl is only loadable via the tccl.
*/
public void testLoader() throws Exception {
ClassLoader thisClassLoader = this.getClass().getClassLoader();
ClassLoader tcclLoader = Thread.currentThread().getContextClassLoader();
// the tccl loader should NOT be the same as the loader that loaded this test class.
assertNotSame("tccl not same as test classloader", thisClassLoader, tcclLoader);
@@ -123,7 +123,7 @@ public class TcclEnabledTestCase extends TestCase {
} catch(ClassNotFoundException ex) {
// ok, expected
}
// MyLog should be loadable via tccl loader
try {
Class clazz = tcclLoader.loadClass(MY_LOG_IMPL);
@@ -140,9 +140,9 @@ public class TcclEnabledTestCase extends TestCase {
*/
public void testTcclLoading() throws Exception {
LogFactory instance = LogFactory.getFactory();
assertEquals(
"Correct LogFactory loaded",
"Correct LogFactory loaded",
"org.apache.commons.logging.impl.LogFactoryImpl",
instance.getClass().getName());

12
src/test/java/org/apache/commons/logging/tccl/logfactory/TcclDisabledTestCase.java
View File

@@ -35,7 +35,7 @@ import org.apache.commons.logging.PathableTestSuite;
public class TcclDisabledTestCase extends TestCase {
public static final String MY_LOG_FACTORY_PKG =
public static final String MY_LOG_FACTORY_PKG =
"org.apache.commons.logging.tccl.custom";
public static final String MY_LOG_FACTORY_IMPL =
@@ -58,7 +58,7 @@ public class TcclDisabledTestCase extends TestCase {
dummy.useExplicitLoader("junit.", Test.class.getClassLoader());
dummy.addLogicalLib("testclasses");
dummy.addLogicalLib("commons-logging");
String thisClassPath = thisClass.getName().replace('.', '/') + ".class";
URL baseUrl = dummy.findResource(thisClassPath);
@@ -70,7 +70,7 @@ public class TcclDisabledTestCase extends TestCase {
// LogFactory class. Therefore if that class can be found, then the
// TCCL must have been used to load it.
PathableClassLoader emptyLoader = new PathableClassLoader(null);
PathableClassLoader parentLoader = new PathableClassLoader(null);
parentLoader.useExplicitLoader("junit.", Test.class.getClassLoader());
parentLoader.addLogicalLib("commons-logging");
@@ -79,7 +79,7 @@ public class TcclDisabledTestCase extends TestCase {
// the custom MyLogFactoryImpl
parentLoader.useExplicitLoader(
MY_LOG_FACTORY_PKG + ".", emptyLoader);
URL propsEnableUrl = new URL(baseUrl, "props_disable_tccl/");
parentLoader.addURL(propsEnableUrl);
@@ -110,7 +110,7 @@ public class TcclDisabledTestCase extends TestCase {
* Verify that MyLogFactoryImpl is only loadable via the tccl.
*/
public void testLoader() throws Exception {
ClassLoader thisClassLoader = this.getClass().getClassLoader();
ClassLoader tcclLoader = Thread.currentThread().getContextClassLoader();
@@ -125,7 +125,7 @@ public class TcclDisabledTestCase extends TestCase {
} catch(ClassNotFoundException ex) {
// ok, expected
}
// MyLogFactoryImpl should be loadable via tccl loader
try {
Class clazz = tcclLoader.loadClass(MY_LOG_FACTORY_IMPL);

14
src/test/java/org/apache/commons/logging/tccl/logfactory/TcclEnabledTestCase.java
View File

@@ -52,7 +52,7 @@ public class TcclEnabledTestCase extends TestCase {
dummy.useExplicitLoader("junit.", Test.class.getClassLoader());
dummy.addLogicalLib("testclasses");
dummy.addLogicalLib("commons-logging");
String thisClassPath = thisClass.getName().replace('.', '/') + ".class";
URL baseUrl = dummy.findResource(thisClassPath);
@@ -64,7 +64,7 @@ public class TcclEnabledTestCase extends TestCase {
// LogFactory class. Therefore if that class can be found, then the
// TCCL must have been used to load it.
PathableClassLoader emptyLoader = new PathableClassLoader(null);
PathableClassLoader parentLoader = new PathableClassLoader(null);
parentLoader.useExplicitLoader("junit.", Test.class.getClassLoader());
parentLoader.addLogicalLib("commons-logging");
@@ -73,7 +73,7 @@ public class TcclEnabledTestCase extends TestCase {
// the cust MyLogFactoryImpl
parentLoader.useExplicitLoader(
"org.apache.commons.logging.tccl.custom.", emptyLoader);
URL propsEnableUrl = new URL(baseUrl, "props_enable_tccl/");
parentLoader.addURL(propsEnableUrl);
@@ -104,7 +104,7 @@ public class TcclEnabledTestCase extends TestCase {
* Verify that MyLogFactoryImpl is only loadable via the tccl.
*/
public void testLoader() throws Exception {
ClassLoader thisClassLoader = this.getClass().getClassLoader();
ClassLoader tcclLoader = Thread.currentThread().getContextClassLoader();
@@ -120,7 +120,7 @@ public class TcclEnabledTestCase extends TestCase {
} catch(ClassNotFoundException ex) {
// ok, expected
}
// MyLogFactoryImpl should be loadable via tccl loader
try {
Class clazz = tcclLoader.loadClass(
@@ -138,9 +138,9 @@ public class TcclEnabledTestCase extends TestCase {
*/
public void testTcclLoading() throws Exception {
LogFactory instance = LogFactory.getFactory();
assertEquals(
"Correct LogFactory loaded",
"Correct LogFactory loaded",
"org.apache.commons.logging.tccl.custom.MyLogFactoryImpl",
instance.getClass().getName());
}