private static Class<?> getFromEvoSuiteClassloader(Class<?> clazz) throws InitializationError { try { /* * properties like REPLACE_CALLS will be set directly in the JUnit files */ // LoggingUtils.loadLogbackForEvoSuite(); /* * This approach does throw away all the possible instrumentation done on the input clazz, * eg code coverage of Emma, Cobertura, Javalanche, etc. * Furthermore, if the classloader used to load EvoRunner is not the same as CUT, * then loading CUTs will fail (this does happen in "mvn test") */ EvoClassLoader classLoader = new EvoClassLoader(); classLoader.skipInstrumentation(clazz.getName()); Thread.currentThread().setContextClassLoader(classLoader); return Class.forName(clazz.getName(), true, classLoader); } catch (ClassNotFoundException e) { throw new InitializationError(e); } }
byte[] byteBuffer = instrumentation.transformBytes(this, className, new ClassReader(is), shouldSkip); createPackageDefinition(fullyQualifiedTargetClass); Class<?> result = defineClass(fullyQualifiedTargetClass, byteBuffer, 0, byteBuffer.length); classes.put(fullyQualifiedTargetClass, result);
/** * Before a new class is defined, we need to create a package definition for it * * @param className */ private void createPackageDefinition(String className){ int i = className.lastIndexOf('.'); if (i != -1) { String pkgname = className.substring(0, i); // Check if package already loaded. Package pkg = getPackage(pkgname); if(pkg==null){ definePackage(pkgname, null, null, null, null, null, null, null); logger.info("Defined package (3): "+getPackage(pkgname)+", "+getPackage(pkgname).hashCode()); } } }
/** * {@inheritDoc} */ @Override public Class<?> loadClass(String name) throws ClassNotFoundException { if ("<evosuite>".equals(name)) throw new ClassNotFoundException(); //first check if already loaded if (!RuntimeInstrumentation.checkIfCanInstrument(name)) { Class<?> result = findLoadedClass(name); if (result != null) { return result; } result = classLoader.loadClass(name); return result; } Class<?> result = classes.get(name); if (result != null) { return result; } else { logger.info("Seeing class for first time: " + name); Class<?> instrumentedClass = instrumentClass(name); return instrumentedClass; } }
private void testConfirmNumberExternal() throws Exception{ assertEquals(IssueWithNumber.RESULT, IssueWithNumber.getResult()); RuntimeInstrumentation.setAvoidInstrumentingShadedClasses(true); ClassPathHandler.getInstance().changeTargetCPtoTheSameAsEvoSuite(); EvoClassLoader loader = new EvoClassLoader(); loader.skipInstrumentation(IssueWithNumber.class.getName()); org.evosuite.runtime.Runtime.getInstance().resetRuntime(); Class<?> klass = loader.loadClass(IssueWithNumber.class.getName()); Method m = klass.getDeclaredMethod("getResult"); String res = (String) m.invoke(null); assertEquals(IssueWithNumber.RESULT, res); }
@Test(timeout = 5000) public void testLoading() throws Exception{ EvoClassLoader loader = new EvoClassLoader(); Class<?> clazz = loader.loadClass(InfiniteWhile.class.getCanonicalName()); Method m = clazz.getMethod("infiniteLoop"); try { m.invoke(null); fail(); }catch(InvocationTargetException e){ //expected Assert.assertTrue(e.getCause() instanceof TooManyResourcesException); } }
@Ignore @Test public void testResetOfMutableEnum() throws Exception{ ClassLoader loader = new EvoClassLoader(); RuntimeSettings.resetStaticState = true; ClassResetter.getInstance().setClassLoader(loader); String cut = MutableEnum.class.getCanonicalName(); Class<?> klass = (Class<MutableEnum>) loader.loadClass(cut); Object[] enums = klass.getEnumConstants(); Assert.assertEquals(2, enums.length); Method getter = klass.getDeclaredMethod("getLetter"); Assert.assertEquals("a", getter.invoke(enums[0])); Assert.assertEquals("b", getter.invoke(enums[1])); Method m = klass.getDeclaredMethod("changeLetter"); m.invoke(enums[0]); Assert.assertEquals("X", getter.invoke(enums[0])); Assert.assertEquals("b", getter.invoke(enums[1])); ClassResetter.getInstance().reset(cut); Assert.assertEquals("a", getter.invoke(enums[0])); Assert.assertEquals("b", getter.invoke(enums[1])); } }
@Test public void testResetOfEnum() throws Exception{ ClassLoader loader = new EvoClassLoader(); RuntimeSettings.resetStaticState = true; ClassResetter.getInstance().setClassLoader(loader); String cut = "com.examples.with.different.packagename.classhandling.FooEnum"; Class<?> klass = loader.loadClass(cut); Method m = klass.getDeclaredMethod("check"); boolean val = false; val = (Boolean) m.invoke(null); Assert.assertTrue(val); ClassResetter.getInstance().reset(cut); //make sure that the reset does not create new enum instance values val = (Boolean) m.invoke(null); Assert.assertTrue(val); }
@Test public void testInitializeClasses(){ EvoClassLoader loader = new EvoClassLoader(); String className = "com.examples.with.different.packagename.classhandling.TimeA"; //no mocking RuntimeSettings.deactivateAllMocking(); boolean problem = ClassStateSupport.initializeClasses(loader, className); Assert.assertFalse(problem); //with mocking RuntimeSettings.mockJVMNonDeterminism = true; className = "com.examples.with.different.packagename.classhandling.TimeB"; problem = ClassStateSupport.initializeClasses(loader,className); Assert.assertFalse(problem); } }