test/068-classloader/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * 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.lang.reflect.Constructor;
 import java.lang.reflect.Method;

 /**
  * Class loader test.
  */
 public class Main {
     /**
      * Main entry point.
      */
     public static void main(String[] args) throws Exception {
         FancyLoader loader;

         loader = new FancyLoader(ClassLoader.getSystemClassLoader());
         //System.out.println("SYSTEM: " + ClassLoader.getSystemClassLoader());
         //System.out.println("ALTERN: " + loader);

         /*
          * This statement has no effect on this program, but it can
          * change the point where a LinkageException is thrown in
          * testImplement().  When this is present the "reference
          * implementation" throws an exception from Class.newInstance(),
          * when it's absent the exception is deferred until the first time
          * we call a method that isn't actually implemented.
          *
          * This isn't the class that fails -- it's a class with the same
          * name in the "fancy" class loader --  but the VM thinks it has a
          * reference to one of these; presumably the difference is that
          * without this the VM finds itself holding a reference to an
          * instance of an uninitialized class.
          */
         System.out.println("base: " + DoubledImplement.class);
         System.out.println("base2: " + DoubledImplement2.class);

         /*
          * Run tests.
          */
         testAccess1(loader);
         testAccess2(loader);
         testAccess3(loader);

         testExtend(loader);
         testExtendOkay(loader);
         testInterface(loader);
         testAbstract(loader);
         testImplement(loader);
         testIfaceImplement(loader);

         testSeparation();

         testClassForName();

         testNullClassLoader();
     }

     static void testNullClassLoader() {
         try {
             /* this is the "alternate" DEX/Jar file */
             String DEX_FILE = System.getenv("DEX_LOCATION") + "/068-classloader-ex.jar";
             /* on Dalvik, this is a DexFile; otherwise, it's null */
             Class<?> mDexClass = Class.forName("dalvik.system.DexFile");
             Constructor<?> ctor = mDexClass.getConstructor(String.class);
             Object mDexFile = ctor.newInstance(DEX_FILE);
             Method meth = mDexClass.getMethod("loadClass", String.class, ClassLoader.class);
             Object klass = meth.invoke(mDexFile, "Mutator", null);
             if (klass == null) {
                 throw new AssertionError("loadClass with nullclass loader failed");
             }
         } catch (Exception e) {
             System.out.println(e);
         }
         System.out.println("Loaded class into null class loader");
     }

     static void testSeparation() {
         FancyLoader loader1 = new FancyLoader(ClassLoader.getSystemClassLoader());
         FancyLoader loader2 = new FancyLoader(ClassLoader.getSystemClassLoader());

         try {
             Class<?> target1 = loader1.loadClass("MutationTarget");
             Class<?> target2 = loader2.loadClass("MutationTarget");

             if (target1 == target2) {
                 throw new RuntimeException("target1 should not be equal to target2");
             }

             Class<?> mutator1 = loader1.loadClass("Mutator");
             Class<?> mutator2 = loader2.loadClass("Mutator");

             if (mutator1 == mutator2) {
                 throw new RuntimeException("mutator1 should not be equal to mutator2");
             }

             runMutator(mutator1, 1);

             int value = getMutationTargetValue(target1);
             if (value != 1) {
                 throw new RuntimeException("target 1 has unexpected value " + value);
             }
             value = getMutationTargetValue(target2);
             if (value != 0) {
                 throw new RuntimeException("target 2 has unexpected value " + value);
             }

             runMutator(mutator2, 2);

             value = getMutationTargetValue(target1);
             if (value != 1) {
                 throw new RuntimeException("target 1 has unexpected value " + value);
             }
             value = getMutationTargetValue(target2);
             if (value != 2) {
                 throw new RuntimeException("target 2 has unexpected value " + value);
             }
         } catch (Exception ex) {
             ex.printStackTrace(System.out);
         }
     }

     private static void runMutator(Class<?> c, int v) throws Exception {
         java.lang.reflect.Method m = c.getDeclaredMethod("mutate", int.class);
         m.invoke(null, v);
     }

     private static int getMutationTargetValue(Class<?> c) throws Exception {
         java.lang.reflect.Field f = c.getDeclaredField("value");
         return f.getInt(null);
     }

     /**
      * See if we can load a class that isn't public to us.  We should be
      * able to load it but not instantiate it.
      */
     static void testAccess1(ClassLoader loader) {
         Class<?> altClass;

         try {
             altClass = loader.loadClass("Inaccessible1");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed");
             cnfe.printStackTrace(System.out);
             return;
         }

         /* instantiate */
         Object obj;
         try {
             obj = altClass.newInstance();
             System.out.println("ERROR: Inaccessible1 was accessible");
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("Got expected access exception #1");
             //System.out.println("+++ " + iae);
             return;
         }
     }

     /**
      * See if we can load a class whose base class is not accessible to it
      * (though the base *is* accessible to us).
      */
     static void testAccess2(ClassLoader loader) {
         Class<?> altClass;

         try {
             altClass = loader.loadClass("Inaccessible2");
             System.out.println("ERROR: Inaccessible2 was accessible: " + altClass);
         } catch (ClassNotFoundException cnfe) {
             Throwable cause = cnfe.getCause();
             if (cause instanceof IllegalAccessError) {
                 System.out.println("Got expected CNFE/IAE #2");
             } else {
                 System.out.println("Got unexpected CNFE/IAE #2");
                 cnfe.printStackTrace(System.out);
             }
         }
     }

     /**
      * See if we can load a class with an inaccessible interface.
      */
     static void testAccess3(ClassLoader loader) {
         Class<?> altClass;

         try {
             altClass = loader.loadClass("Inaccessible3");
             System.out.println("ERROR: Inaccessible3 was accessible: " + altClass);
         } catch (ClassNotFoundException cnfe) {
             Throwable cause = cnfe.getCause();
             if (cause instanceof IllegalAccessError) {
                 System.out.println("Got expected CNFE/IAE #3");
             } else {
                 System.out.println("Got unexpected CNFE/IAE #3");
                 cnfe.printStackTrace(System.out);
             }
         }
     }

     /**
      * Test a doubled class that extends the base class.
      */
     static void testExtend(ClassLoader loader) {
         Class<?> doubledExtendClass;
         Object obj;

         /* get the "alternate" version of DoubledExtend */
         try {
             doubledExtendClass = loader.loadClass("DoubledExtend");
             //System.out.println("+++ DoubledExtend is " + doubledExtendClass
             //    + " in " + doubledExtendClass.getClassLoader());
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = doubledExtendClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             System.out.println("Got expected LinkageError on DE");
             return;
         }

         /* use the base class reference to get a CL-specific instance */
         Base baseRef = (Base) obj;
         DoubledExtend de = baseRef.getExtended();

         /* try to call through it */
         try {
             String result;

             result = Base.doStuff(de);
             System.out.println("ERROR: did not get LinkageError on DE");
             System.out.println("(result=" + result + ")");
         } catch (LinkageError le) {
             System.out.println("Got expected LinkageError on DE");
             return;
         }
     }

     /**
      * Test a doubled class that extends the base class, but is okay since
      * it doesn't override the base class method.
      */
     static void testExtendOkay(ClassLoader loader) {
         Class<?> doubledExtendOkayClass;
         Object obj;

         /* get the "alternate" version of DoubledExtendOkay */
         try {
             doubledExtendOkayClass = loader.loadClass("DoubledExtendOkay");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = doubledExtendOkayClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             System.out.println("Got unexpected LinkageError on DEO");
             le.printStackTrace(System.out);
             return;
         }

         /* use the base class reference to get a CL-specific instance */
         BaseOkay baseRef = (BaseOkay) obj;
         DoubledExtendOkay de = baseRef.getExtended();

         /* try to call through it */
         try {
             String result;

             result = BaseOkay.doStuff(de);
             System.out.println("Got DEO result " + result);
         } catch (LinkageError le) {
             System.out.println("Got unexpected LinkageError on DEO");
             le.printStackTrace(System.out);
             return;
         }
     }

     /**
      * Try to access a doubled class through a class that implements
      * an interface declared in a different class.
      */
     static void testInterface(ClassLoader loader) {
         Class<?> getDoubledClass;
         Object obj;

         /* get GetDoubled from the "alternate" class loader */
         try {
             getDoubledClass = loader.loadClass("GetDoubled");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = getDoubledClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             // Dalvik bails here
             System.out.println("Got LinkageError on GD");
             return;
         }

         /*
          * Cast the object to the interface, and try to use it.
          */
         IGetDoubled iface = (IGetDoubled) obj;
         try {
             /* "de" will be the wrong variety of DoubledExtendOkay */
             DoubledExtendOkay de = iface.getDoubled();
             // reference impl bails here
             String str = de.getStr();
         } catch (LinkageError le) {
             System.out.println("Got LinkageError on GD");
             return;
         }
         System.out.println("Should have failed by now on GetDoubled");
     }

     /**
      * Throw an abstract class into the middle and see what happens.
      */
     static void testAbstract(ClassLoader loader) {
         Class<?> abstractGetClass;
         Object obj;

         /* get AbstractGet from the "alternate" loader */
         try {
             abstractGetClass = loader.loadClass("AbstractGet");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass ta failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = abstractGetClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             System.out.println("Got LinkageError on TA");
             return;
         }

         /* use the base class reference to get a CL-specific instance */
         BaseOkay baseRef = (BaseOkay) obj;
         DoubledExtendOkay de = baseRef.getExtended();

         /* try to call through it */
         try {
             String result;

             result = BaseOkay.doStuff(de);
         } catch (LinkageError le) {
             System.out.println("Got LinkageError on TA");
             return;
         }
         System.out.println("Should have failed by now in testAbstract");
     }

     /**
      * Test a doubled class that implements a common interface.
      */
     static void testImplement(ClassLoader loader) {
         Class<?> doubledImplementClass;
         Object obj;

         useImplement(new DoubledImplement(), true);

         /* get the "alternate" version of DoubledImplement */
         try {
             doubledImplementClass = loader.loadClass("DoubledImplement");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = doubledImplementClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             System.out.println("Got LinkageError on DI (early)");
             return;
         }

         /* if we lived this long, try to do something with it */
         ICommon icommon = (ICommon) obj;
         useImplement(icommon.getDoubledInstance(), false);
     }

     /**
      * Do something with a DoubledImplement instance.
      */
     static void useImplement(DoubledImplement di, boolean isOne) {
         //System.out.println("useObject: " + di.toString() + " -- "
         //    + di.getClass().getClassLoader());
         try {
             di.one();
             if (!isOne) {
                 System.out.println("ERROR: did not get LinkageError on DI");
             }
         } catch (LinkageError le) {
             if (!isOne) {
                 System.out.println("Got LinkageError on DI (late)");
             } else {
                 throw le;
             }
         }
     }


     /**
      * Test a class that implements an interface with a super-interface
      * that refers to a doubled class.
      */
     static void testIfaceImplement(ClassLoader loader) {
         Class<?> ifaceImplClass;
         Object obj;

         /*
          * Create an instance of IfaceImpl.  We also pull in
          * DoubledImplement2 from the other class loader; without this
          * we don't fail in some implementations.
          */
         try {
             ifaceImplClass = loader.loadClass("IfaceImpl");
             ifaceImplClass = loader.loadClass("DoubledImplement2");
         } catch (ClassNotFoundException cnfe) {
             System.out.println("loadClass failed: " + cnfe);
             return;
         }

         /* instantiate */
         try {
             obj = ifaceImplClass.newInstance();
         } catch (InstantiationException ie) {
             System.out.println("newInstance failed: " + ie);
             return;
         } catch (IllegalAccessException iae) {
             System.out.println("newInstance failed: " + iae);
             return;
         } catch (LinkageError le) {
             System.out.println("Got LinkageError on IDI (early)");
             //System.out.println(le);
             return;
         }

         /*
          * Without the pre-load of FancyLoader->DoubledImplement2, some
          * implementations will happily execute through this part.  "obj"
          * comes from FancyLoader, but the di2 returned from ifaceSuper
          * comes from the application class loader.
          */
         IfaceSuper ifaceSuper = (IfaceSuper) obj;
         DoubledImplement2 di2 = ifaceSuper.getDoubledInstance2();
         di2.one();
     }

     static void testClassForName() throws Exception {
         System.out.println(Class.forName("Main").toString());
         try {
             System.out.println(Class.forName("Main", false, null).toString());
         } catch (ClassNotFoundException expected) {
             System.out.println("Got expected ClassNotFoundException");
         }
     }
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* 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.lang.reflect.Constructor;
	import java.lang.reflect.Method;

	/**
	* Class loader test.
	*/
	public class Main {
	/**
	* Main entry point.
	*/
	public static void main(String[] args) throws Exception {
	FancyLoader loader;

	loader = new FancyLoader(ClassLoader.getSystemClassLoader());
	//System.out.println("SYSTEM: " + ClassLoader.getSystemClassLoader());
	//System.out.println("ALTERN: " + loader);

	/*
	* This statement has no effect on this program, but it can
	* change the point where a LinkageException is thrown in
	* testImplement(). When this is present the "reference
	* implementation" throws an exception from Class.newInstance(),
	* when it's absent the exception is deferred until the first time
	* we call a method that isn't actually implemented.
	*
	* This isn't the class that fails -- it's a class with the same
	* name in the "fancy" class loader -- but the VM thinks it has a
	* reference to one of these; presumably the difference is that
	* without this the VM finds itself holding a reference to an
	* instance of an uninitialized class.
	*/
	System.out.println("base: " + DoubledImplement.class);
	System.out.println("base2: " + DoubledImplement2.class);

	/*
	* Run tests.
	*/
	testAccess1(loader);
	testAccess2(loader);
	testAccess3(loader);

	testExtend(loader);
	testExtendOkay(loader);
	testInterface(loader);
	testAbstract(loader);
	testImplement(loader);
	testIfaceImplement(loader);

	testSeparation();

	testClassForName();

	testNullClassLoader();
	}

	static void testNullClassLoader() {
	try {
	/* this is the "alternate" DEX/Jar file */
	String DEX_FILE = System.getenv("DEX_LOCATION") + "/068-classloader-ex.jar";
	/* on Dalvik, this is a DexFile; otherwise, it's null */
	Class<?> mDexClass = Class.forName("dalvik.system.DexFile");
	Constructor<?> ctor = mDexClass.getConstructor(String.class);
	Object mDexFile = ctor.newInstance(DEX_FILE);
	Method meth = mDexClass.getMethod("loadClass", String.class, ClassLoader.class);
	Object klass = meth.invoke(mDexFile, "Mutator", null);
	if (klass == null) {
	throw new AssertionError("loadClass with nullclass loader failed");
	}
	} catch (Exception e) {
	System.out.println(e);
	}
	System.out.println("Loaded class into null class loader");
	}

	static void testSeparation() {
	FancyLoader loader1 = new FancyLoader(ClassLoader.getSystemClassLoader());
	FancyLoader loader2 = new FancyLoader(ClassLoader.getSystemClassLoader());

	try {
	Class<?> target1 = loader1.loadClass("MutationTarget");
	Class<?> target2 = loader2.loadClass("MutationTarget");

	if (target1 == target2) {
	throw new RuntimeException("target1 should not be equal to target2");
	}

	Class<?> mutator1 = loader1.loadClass("Mutator");
	Class<?> mutator2 = loader2.loadClass("Mutator");

	if (mutator1 == mutator2) {
	throw new RuntimeException("mutator1 should not be equal to mutator2");
	}

	runMutator(mutator1, 1);

	int value = getMutationTargetValue(target1);
	if (value != 1) {
	throw new RuntimeException("target 1 has unexpected value " + value);
	}
	value = getMutationTargetValue(target2);
	if (value != 0) {
	throw new RuntimeException("target 2 has unexpected value " + value);
	}

	runMutator(mutator2, 2);

	value = getMutationTargetValue(target1);
	if (value != 1) {
	throw new RuntimeException("target 1 has unexpected value " + value);
	}
	value = getMutationTargetValue(target2);
	if (value != 2) {
	throw new RuntimeException("target 2 has unexpected value " + value);
	}
	} catch (Exception ex) {
	ex.printStackTrace(System.out);
	}
	}

	private static void runMutator(Class<?> c, int v) throws Exception {
	java.lang.reflect.Method m = c.getDeclaredMethod("mutate", int.class);
	m.invoke(null, v);
	}

	private static int getMutationTargetValue(Class<?> c) throws Exception {
	java.lang.reflect.Field f = c.getDeclaredField("value");
	return f.getInt(null);
	}

	/**
	* See if we can load a class that isn't public to us. We should be
	* able to load it but not instantiate it.
	*/
	static void testAccess1(ClassLoader loader) {
	Class<?> altClass;

	try {
	altClass = loader.loadClass("Inaccessible1");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed");
	cnfe.printStackTrace(System.out);
	return;
	}

	/* instantiate */
	Object obj;
	try {
	obj = altClass.newInstance();
	System.out.println("ERROR: Inaccessible1 was accessible");
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("Got expected access exception #1");
	//System.out.println("+++ " + iae);
	return;
	}
	}

	/**
	* See if we can load a class whose base class is not accessible to it
	* (though the base is accessible to us).
	*/
	static void testAccess2(ClassLoader loader) {
	Class<?> altClass;

	try {
	altClass = loader.loadClass("Inaccessible2");
	System.out.println("ERROR: Inaccessible2 was accessible: " + altClass);
	} catch (ClassNotFoundException cnfe) {
	Throwable cause = cnfe.getCause();
	if (cause instanceof IllegalAccessError) {
	System.out.println("Got expected CNFE/IAE #2");
	} else {
	System.out.println("Got unexpected CNFE/IAE #2");
	cnfe.printStackTrace(System.out);
	}
	}
	}

	/**
	* See if we can load a class with an inaccessible interface.
	*/
	static void testAccess3(ClassLoader loader) {
	Class<?> altClass;

	try {
	altClass = loader.loadClass("Inaccessible3");
	System.out.println("ERROR: Inaccessible3 was accessible: " + altClass);
	} catch (ClassNotFoundException cnfe) {
	Throwable cause = cnfe.getCause();
	if (cause instanceof IllegalAccessError) {
	System.out.println("Got expected CNFE/IAE #3");
	} else {
	System.out.println("Got unexpected CNFE/IAE #3");
	cnfe.printStackTrace(System.out);
	}
	}
	}

	/**
	* Test a doubled class that extends the base class.
	*/
	static void testExtend(ClassLoader loader) {
	Class<?> doubledExtendClass;
	Object obj;

	/* get the "alternate" version of DoubledExtend */
	try {
	doubledExtendClass = loader.loadClass("DoubledExtend");
	//System.out.println("+++ DoubledExtend is " + doubledExtendClass
	// + " in " + doubledExtendClass.getClassLoader());
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = doubledExtendClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	System.out.println("Got expected LinkageError on DE");
	return;
	}

	/* use the base class reference to get a CL-specific instance */
	Base baseRef = (Base) obj;
	DoubledExtend de = baseRef.getExtended();

	/* try to call through it */
	try {
	String result;

	result = Base.doStuff(de);
	System.out.println("ERROR: did not get LinkageError on DE");
	System.out.println("(result=" + result + ")");
	} catch (LinkageError le) {
	System.out.println("Got expected LinkageError on DE");
	return;
	}
	}

	/**
	* Test a doubled class that extends the base class, but is okay since
	* it doesn't override the base class method.
	*/
	static void testExtendOkay(ClassLoader loader) {
	Class<?> doubledExtendOkayClass;
	Object obj;

	/* get the "alternate" version of DoubledExtendOkay */
	try {
	doubledExtendOkayClass = loader.loadClass("DoubledExtendOkay");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = doubledExtendOkayClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	System.out.println("Got unexpected LinkageError on DEO");
	le.printStackTrace(System.out);
	return;
	}

	/* use the base class reference to get a CL-specific instance */
	BaseOkay baseRef = (BaseOkay) obj;
	DoubledExtendOkay de = baseRef.getExtended();

	/* try to call through it */
	try {
	String result;

	result = BaseOkay.doStuff(de);
	System.out.println("Got DEO result " + result);
	} catch (LinkageError le) {
	System.out.println("Got unexpected LinkageError on DEO");
	le.printStackTrace(System.out);
	return;
	}
	}

	/**
	* Try to access a doubled class through a class that implements
	* an interface declared in a different class.
	*/
	static void testInterface(ClassLoader loader) {
	Class<?> getDoubledClass;
	Object obj;

	/* get GetDoubled from the "alternate" class loader */
	try {
	getDoubledClass = loader.loadClass("GetDoubled");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = getDoubledClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	// Dalvik bails here
	System.out.println("Got LinkageError on GD");
	return;
	}

	/*
	* Cast the object to the interface, and try to use it.
	*/
	IGetDoubled iface = (IGetDoubled) obj;
	try {
	/* "de" will be the wrong variety of DoubledExtendOkay */
	DoubledExtendOkay de = iface.getDoubled();
	// reference impl bails here
	String str = de.getStr();
	} catch (LinkageError le) {
	System.out.println("Got LinkageError on GD");
	return;
	}
	System.out.println("Should have failed by now on GetDoubled");
	}

	/**
	* Throw an abstract class into the middle and see what happens.
	*/
	static void testAbstract(ClassLoader loader) {
	Class<?> abstractGetClass;
	Object obj;

	/* get AbstractGet from the "alternate" loader */
	try {
	abstractGetClass = loader.loadClass("AbstractGet");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass ta failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = abstractGetClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	System.out.println("Got LinkageError on TA");
	return;
	}

	/* use the base class reference to get a CL-specific instance */
	BaseOkay baseRef = (BaseOkay) obj;
	DoubledExtendOkay de = baseRef.getExtended();

	/* try to call through it */
	try {
	String result;

	result = BaseOkay.doStuff(de);
	} catch (LinkageError le) {
	System.out.println("Got LinkageError on TA");
	return;
	}
	System.out.println("Should have failed by now in testAbstract");
	}

	/**
	* Test a doubled class that implements a common interface.
	*/
	static void testImplement(ClassLoader loader) {
	Class<?> doubledImplementClass;
	Object obj;

	useImplement(new DoubledImplement(), true);

	/* get the "alternate" version of DoubledImplement */
	try {
	doubledImplementClass = loader.loadClass("DoubledImplement");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = doubledImplementClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	System.out.println("Got LinkageError on DI (early)");
	return;
	}

	/* if we lived this long, try to do something with it */
	ICommon icommon = (ICommon) obj;
	useImplement(icommon.getDoubledInstance(), false);
	}

	/**
	* Do something with a DoubledImplement instance.
	*/
	static void useImplement(DoubledImplement di, boolean isOne) {
	//System.out.println("useObject: " + di.toString() + " -- "
	// + di.getClass().getClassLoader());
	try {
	di.one();
	if (!isOne) {
	System.out.println("ERROR: did not get LinkageError on DI");
	}
	} catch (LinkageError le) {
	if (!isOne) {
	System.out.println("Got LinkageError on DI (late)");
	} else {
	throw le;
	}
	}
	}


	/**
	* Test a class that implements an interface with a super-interface
	* that refers to a doubled class.
	*/
	static void testIfaceImplement(ClassLoader loader) {
	Class<?> ifaceImplClass;
	Object obj;

	/*
	* Create an instance of IfaceImpl. We also pull in
	* DoubledImplement2 from the other class loader; without this
	* we don't fail in some implementations.
	*/
	try {
	ifaceImplClass = loader.loadClass("IfaceImpl");
	ifaceImplClass = loader.loadClass("DoubledImplement2");
	} catch (ClassNotFoundException cnfe) {
	System.out.println("loadClass failed: " + cnfe);
	return;
	}

	/* instantiate */
	try {
	obj = ifaceImplClass.newInstance();
	} catch (InstantiationException ie) {
	System.out.println("newInstance failed: " + ie);
	return;
	} catch (IllegalAccessException iae) {
	System.out.println("newInstance failed: " + iae);
	return;
	} catch (LinkageError le) {
	System.out.println("Got LinkageError on IDI (early)");
	//System.out.println(le);
	return;
	}

	/*
	* Without the pre-load of FancyLoader->DoubledImplement2, some
	* implementations will happily execute through this part. "obj"
	* comes from FancyLoader, but the di2 returned from ifaceSuper
	* comes from the application class loader.
	*/
	IfaceSuper ifaceSuper = (IfaceSuper) obj;
	DoubledImplement2 di2 = ifaceSuper.getDoubledInstance2();
	di2.one();
	}

	static void testClassForName() throws Exception {
	System.out.println(Class.forName("Main").toString());
	try {
	System.out.println(Class.forName("Main", false, null).toString());
	} catch (ClassNotFoundException expected) {
	System.out.println("Got expected ClassNotFoundException");
	}
	}
	}