public void addException(Throwable exception) { int currentPos = this.tc.size()-1; if (currentPos<0) throw new IllegalStateException("Cannot add exception to empty test case"); if (exceptions.containsKey(currentPos)) { throw new IllegalStateException("Statement already contains an exception!"); } exceptions.put(currentPos, exception); } }
/** {@inheritDoc} */ @Override public int sizeWithAssertions() { return this.size() + this.getAssertions().size(); }
/** {@inheritDoc} */ @Override public void remove(int position) { logger.debug("Removing statement {}", position); if (position >= size()) { return; } statements.remove(position); assert (isValid()); // for(Statement s : statements) { // for(Asss.assertions) // } }
/** {@inheritDoc} */ @Override public boolean hasObject(Type type, int position) { for (int i = 0; i < position && i < size(); i++) { Statement st = statements.get(i); if (st.getReturnValue() == null) continue; // Nop if (st.getReturnValue().isAssignableTo(type)) { return true; } } return false; }
@Test public void testIntegerDependency() throws ConstructionFailedException, NoSuchMethodException, SecurityException { TestFactory testFactory = TestFactory.getInstance(); GenericMethod method = new GenericMethod( FactoryExample.class.getMethod("testByte", byte.class, byte.class), FactoryExample.class); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; testFactory.addMethod(test, method, 0, 0); String code = test.toCode(); System.out.println(code); assertEquals(4, test.size()); assertTrue(code.contains("factoryExample0.testByte(byte0, byte1)")); }
@Test public void testAddFieldAssignment() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addFieldAssignment(test, field, 0, 0); assertEquals(3, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertFalse(code.contains("factoryExample1")); }
@Test public void testAddField() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addField(test, field, 0, 0); assertEquals(2, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertFalse(code.contains("factoryExample1")); }
@Test public void testAddFieldReuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addField(test, field, 0, 0); assertEquals(2, test.size()); Properties.PRIMITIVE_REUSE_PROBABILITY = 1.0; Properties.OBJECT_REUSE_PROBABILITY = 1.0; testFactory.reset(); testFactory.addField(test, field, 2, 0); assertEquals(3, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertFalse(code.contains("factoryExample1")); }
@Test public void testAddFieldNoreuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addField(test, field, 0, 0); assertEquals(2, test.size()); testFactory.reset(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; testFactory.addField(test, field, 2, 0); System.out.println(test.toCode()); assertEquals(4, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertTrue(code.contains("factoryExample1.setMe")); assertFalse(code.contains("factoryExample2")); }
@Test public void testStaticMethod() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericMethod method = new GenericMethod(sut.getMethod("testStatic"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addMethod(test, method, 0, 0); assertEquals(1, test.size()); testFactory.reset(); testFactory.addMethod(test, method, 1, 0); assertEquals(2, test.size()); String code = test.toCode(); System.out.println(code); // With object reuse being 0, there should be no new instance of this object assertTrue(code.contains("FactoryExample.testStatic()")); // No instance assertFalse(code.contains("FactoryExample0")); }
@Test public void testAddFieldAssignmentNoreuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addFieldAssignment(test, field, 0, 0); assertEquals(3, test.size()); testFactory.reset(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; testFactory.addFieldAssignment(test, field, 3, 0); assertEquals(6, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertTrue(code.contains("factoryExample1.setMe")); assertFalse(code.contains("factoryExample2")); }
@Test public void testAddFieldAssignmentReuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, NoSuchFieldException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); testFactory.addFieldAssignment(test, field, 0, 0); assertEquals(3, test.size()); Properties.PRIMITIVE_REUSE_PROBABILITY = 1.0; Properties.OBJECT_REUSE_PROBABILITY = 1.0; testFactory.reset(); testFactory.addFieldAssignment(test, field, 3, 0); assertEquals(4, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0.setMe")); assertFalse(code.contains("factoryExample1")); }
@Test public void testAddConstructor() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericConstructor method = new GenericConstructor(sut.getConstructor(), sut); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; testFactory.addConstructor(test, method, 0, 0); testFactory.reset(); assertEquals(1, test.size()); testFactory.addConstructor(test, method, 0, 0); assertEquals(2, test.size()); String code = test.toCode(); System.out.println(code); assertTrue(code.contains("factoryExample0")); assertTrue(code.contains("factoryExample1")); }
@Test public void testGetCandidatesForReuse() throws ClassNotFoundException, NoSuchFieldException, ConstructionFailedException, NoSuchMethodException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); Properties.PRIMITIVE_REUSE_PROBABILITY = 1.0; Properties.OBJECT_REUSE_PROBABILITY = 1.0; DefaultTestCase test = new DefaultTestCase(); GenericConstructor constructor = new GenericConstructor(sut.getConstructor(), sut); VariableReference var1 = testFactory.addConstructor(test, constructor, 0, 0); test.addStatement(new CharPrimitiveStatement(test,'-')); GenericMethod method = new GenericMethod(sut.getMethod("testInt", int.class), sut); testFactory.addMethodFor(test, var1, method, 2); MethodStatement stmt = (MethodStatement)test.getStatement(test.size()-1); VariableReference var = stmt.getParameterReferences().get(0); assertNotEquals("Char should not be passed as Integer", var.getType(), char.class); assertEquals("Incorrect test size", 4, test.size()); } }
@Test public void testObjectDependencyReuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericMethod method = new GenericMethod( sut.getMethod("testByte", byte.class, byte.class), sut); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 1.0; Properties.OBJECT_REUSE_PROBABILITY = 1.0; testFactory.addMethod(test, method, 0, 0); testFactory.addMethod(test, method, 3, 0); String code = test.toCode(); System.out.println(code); // With object reuse being 0, there should be no new instance of this object assertEquals(4, test.size()); assertTrue(code.contains("factoryExample0.testByte(byte0, byte0)")); assertFalse(code.contains("factoryExample1")); }
@Test public void testObjectDependencyNoReuse() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericMethod method = new GenericMethod(sut.getMethod("testByte", byte.class, byte.class), sut); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; testFactory.addMethod(test, method, 0, 0); testFactory.reset(); testFactory.addMethod(test, method, 4, 0); String code = test.toCode(); System.out.println(code); // With object reuse being 0, there should be no new instance of this object assertEquals(8, test.size()); assertTrue(code.contains("factoryExample0.testByte(byte0, byte1)")); // byte2 is the first return value assertTrue(code.contains("factoryExample1.testByte(byte3, byte4")); }
@Test public void testFieldFor() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException, NoSuchFieldException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericConstructor constructor = new GenericConstructor(sut.getConstructor(), sut); GenericField field = new GenericField(sut.getField("setMe"), sut); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; VariableReference var1 = testFactory.addConstructor(test, constructor, 0, 0); testFactory.reset(); VariableReference var2 = testFactory.addConstructor(test, constructor, 1, 0); testFactory.addFieldFor(test, var1, field, 2); testFactory.reset(); testFactory.addFieldFor(test, var2, field, 3); String code = test.toCode(); System.out.println(code); assertEquals(6, test.size()); assertTrue(code.contains("factoryExample0.setMe")); // byte2 is the first return value assertTrue(code.contains("factoryExample1.setMe")); }
@Test public void testMethodFor() throws ConstructionFailedException, NoSuchMethodException, SecurityException, ClassNotFoundException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); GenericConstructor constructor = new GenericConstructor(sut.getConstructor(), sut); GenericMethod method = new GenericMethod(sut.getMethod("testByte", byte.class, byte.class), sut); DefaultTestCase test = new DefaultTestCase(); Properties.PRIMITIVE_REUSE_PROBABILITY = 0.0; Properties.OBJECT_REUSE_PROBABILITY = 0.0; VariableReference var1 = testFactory.addConstructor(test, constructor, 0, 0); testFactory.reset(); VariableReference var2 = testFactory.addConstructor(test, constructor, 1, 0); testFactory.addMethodFor(test, var1, method, 2); testFactory.reset(); testFactory.addMethodFor(test, var2, method, 3); String code = test.toCode(); System.out.println(code); assertEquals(8, test.size()); assertTrue(code.contains("factoryExample0.testByte")); // byte2 is the first return value assertTrue(code.contains("factoryExample1.testByte")); }
testFactory.addMethod(test, method, 11, 0); assertEquals(12, test.size());
@Test public void minimizeSuiteOnlyWithVariables() { DefaultTestCase test = new DefaultTestCase(); for (int i = 0; i < 10; i++) { IntPrimitiveStatement ips = new IntPrimitiveStatement(test, i); test.addStatement(ips); } assertEquals(10, test.size()); TestSuiteChromosome tsc = new TestSuiteChromosome(); tsc.addTest(test); TestSuiteFitnessFunction ff = new BranchCoverageSuiteFitness(); double previous_fitness = ff.getFitness(tsc); tsc.setFitness(ff, previous_fitness); assertEquals(0.0, previous_fitness, 0.0); TestSuiteMinimizer minimizer = new TestSuiteMinimizer(new BranchCoverageFactory()); minimizer.minimize(tsc, false); assertEquals(0, tsc.getTests().size()); double fitness = ff.getFitness(tsc); assertEquals(previous_fitness, fitness, 0.0); }