// Should always give the same result for loadClass(string) @Test public void testLoadsClassesRepeatedly() throws ClassNotFoundException { final List<String> classNames = new ArrayList<>(); classNames.add("java.lang.Object"); classNames.add("instrumentertest.Outer"); classNames.add("instrumentertest.Outer$Inner"); classNames.addAll(IndividualClassLoader.alwaysRedefine); final List<Class<?>> loadedClasses = new ArrayList<>(); // Reloading consecutively should work for (String className : classNames) { final Class<?> loadedClass = l1.loadClass(className); final Class<?> reLoadedClass = l1.loadClass(className); assertEquals(loadedClass, reLoadedClass); loadedClasses.add(loadedClass); } // Reloading in a different order should work for (int i = 0; i < classNames.size(); i++) { assertEquals(l1.loadClass(classNames.get(i)), loadedClasses.get(i)); } }
@Test public void testLoadFromJar() throws Exception { File jar = Files.createTempFile("battlecode-test", ".jar").toFile(); jar.deleteOnExit(); ZipOutputStream z = new ZipOutputStream(new FileOutputStream(jar)); ZipEntry classEntry = new ZipEntry("instrumentertest/Nothing.class"); z.putNextEntry(classEntry); IOUtils.copy( getClass().getClassLoader().getResourceAsStream("instrumentertest/Nothing.class"), z); z.closeEntry(); z.close(); IndividualClassLoader jarLoader = new IndividualClassLoader( "instrumentertest", new IndividualClassLoader.Cache(jar.toURI().toURL())); Class<?> jarClass = jarLoader.loadClass("instrumentertest.Nothing"); URL jarClassLocation = jarClass.getResource("Nothing.class"); // EXTREMELY scientific assertTrue(jarClassLocation.toString().startsWith("jar:")); assertTrue(jarClassLocation.toString().contains(jar.toURI().toURL().toString())); }
@Before public void resetIndividualClassLoader() throws Exception { sharedCache = new IndividualClassLoader.Cache(); l1 = new IndividualClassLoader("instrumentertest", sharedCache); l2 = new IndividualClassLoader("instrumentertest", sharedCache); // Set up noop RobotMonitors. SandboxedRobotPlayer.Pauser pauser = () -> {}; SandboxedRobotPlayer.Killer killer = () -> {}; final Class<?> monitor1 = l1.loadClass("battlecode.instrumenter.inject.RobotMonitor"); monitor1 .getMethod( "init", SandboxedRobotPlayer.Pauser.class, SandboxedRobotPlayer.Killer.class, int.class) .invoke(null, pauser, killer, 0); monitor1.getMethod("setBytecodeLimit", int.class).invoke(null, Integer.MAX_VALUE); final Class<?> monitor2 = l2.loadClass("battlecode.instrumenter.inject.RobotMonitor"); monitor2 .getMethod( "init", SandboxedRobotPlayer.Pauser.class, SandboxedRobotPlayer.Killer.class, int.class) .invoke(null, pauser, killer, 0); monitor2.getMethod("setBytecodeLimit", int.class).invoke(null, Integer.MAX_VALUE); }
// If a player class overrides hashCode, hashCode should work normally. // If a player class *doesn't* override hashCode, we should replace calls to it // with a deterministic hash code function. @Test public void testHashCodeInstrumentation() throws Exception { final Class<?> overridesClass = l1.loadClass("instrumentertest.OverridesHashCode"); final Method getHashCodeOverrides = overridesClass.getMethod("getHashCode"); final Object overrides = overridesClass.newInstance(); assertEquals(57, getHashCodeOverrides.invoke(overrides)); assertEquals(57, getHashCodeOverrides.invoke(overrides)); final Class<?> notOverridesClass1 = l1.loadClass("instrumentertest.DoesntOverrideHashCode"); final Method getHashCodeNotOverrides1 = notOverridesClass1.getMethod("getHashCode"); final Object notOverrides1a = notOverridesClass1.newInstance(); final Object notOverrides1b = notOverridesClass1.newInstance(); assertEquals( getHashCodeNotOverrides1.invoke(notOverrides1a), getHashCodeNotOverrides1.invoke(notOverrides1a)); assertEquals( getHashCodeNotOverrides1.invoke(notOverrides1b), getHashCodeNotOverrides1.invoke(notOverrides1b)); final Class<?> notOverridesClass2 = l2.loadClass("instrumentertest.DoesntOverrideHashCode"); final Method getHashCodeNotOverrides2 = notOverridesClass2.getMethod("getHashCode"); final Object notOverrides2a = notOverridesClass2.newInstance(); final Object notOverrides2b = notOverridesClass2.newInstance(); assertEquals( getHashCodeNotOverrides2.invoke(notOverrides2a), getHashCodeNotOverrides2.invoke(notOverrides2a)); assertEquals( getHashCodeNotOverrides2.invoke(notOverrides2b), getHashCodeNotOverrides2.invoke(notOverrides2b)); // hashCode should be deterministic across loaders (assuming it is called // in the same order.) assertEquals( getHashCodeNotOverrides1.invoke(notOverrides1a), getHashCodeNotOverrides2.invoke(notOverrides2a)); assertEquals( getHashCodeNotOverrides1.invoke(notOverrides1b), getHashCodeNotOverrides2.invoke(notOverrides2b)); }
@Test public void testIllegalMethodsFail() throws Exception { final String[] classNames = new String[] { "instrumentertest.CallsIllegalMethods$CallsWait", "instrumentertest.CallsIllegalMethods$CallsClassForName", "instrumentertest.CallsIllegalMethods$CallsStringIntern", "instrumentertest.CallsIllegalMethods$CallsSystemNanoTime", "instrumentertest.CallsIllegalMethods$CreatesFilePrintStream", }; for (String className : classNames) { try { l1.loadClass(className); } catch (InstrumentationException e) { // Reset teamsWithErrors. continue; } fail("Didn't outlaw illegal class: " + className); } }
// Should reload always-reloadable classes between instances. @Test public void testReloadsAlwaysReloadClasses() throws ClassNotFoundException { for (String alwaysRedefine : IndividualClassLoader.alwaysRedefine) { assertNotEquals(l1.loadClass(alwaysRedefine), l2.loadClass(alwaysRedefine)); } }
// Should reload player classes between instances. @Test public void testReloadsPlayerClasses() throws ClassNotFoundException { assertNotEquals(l1.loadClass("instrumentertest.Outer"), l2.loadClass("instrumentertest.Outer")); }
@Test public void testCanUseEnumMap() throws Exception { l1.loadClass("instrumentertest.UsesEnumMap"); }
@Test public void testMathRandom() throws Exception { l1.loadClass("instrumentertest.CallsMathRandom"); }
@Test public void testCanUseLambda() throws Exception { l1.loadClass("instrumentertest.LegalMethodReference"); }
@Test(expected = InstrumentationException.class) public void testCantReferenceIllegalMethod() throws Exception { l1.loadClass("instrumentertest.IllegalMethodReference"); }
@Test(expected = InstrumentationException.class) public void testCantReflect() throws Exception { l1.loadClass("instrumentertest.Reflection"); }
@Test public void testStringFormat() throws Exception { final Class<?> c = l1.loadClass("instrumentertest.StringFormat"); c.getMethod("run").invoke(null); }
@Test public void testZombieSpawnSchedule() throws Exception { final Class<?> c = l1.loadClass("instrumentertest.UsesSpawnSchedule"); c.getMethod("run").invoke(null); }
@Test public void testLambdas() throws Exception { final Class<?> c = l1.loadClass("instrumentertest.UsesLambda"); c.getMethod("run").invoke(null); }
// Should give already-loaded system classes for most things. @Test public void testNoUnnecessaryReloads() throws ClassNotFoundException { for (Class<?> theClass : NEVER_RELOAD) { assertEquals(theClass, l1.loadClass(theClass.getName())); } }