@Test public void testUniqueConstructors() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); Properties.JEE = true; factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // doing it a second time should fail try { factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); Assert.fail(); } catch (Exception e) { // expected } }
@Test public void testInitializingBoundedVariable_wrong_atMostOnce() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // initializing bounding variable method called directly after the new factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 1, 0); Assert.assertEquals(2, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); // this should be invalid, as executePostConstruct can be used only once on same bounded // variable factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 2, 0); Assert.assertEquals(3, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testInitializingBoundedVariable_correct() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // initializing bounding variable method called directly after the new factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 1, 0); // method on servlet after the bounding variable initialization: it is ok factory.addMethodFor( tc.getTestCase(), servlet, new GenericMethod(FakeServlet.class.getDeclaredMethod("foo"), FakeServlet.class), 2); Assert.assertEquals(3, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testInitializingBoundedVariable_correct_severalCalls() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // both calls on same bounding variable factory.addMethod( tc.getTestCase(), new GenericMethod( ConstraintVerifierTest.class.getDeclaredMethod("fakeInjection", Servlet.class), ConstraintVerifierTest.class), 1, 0); // this is an atMostOnce type factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 2, 0); Assert.assertEquals(3, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testInitializingBoundedVariable_wrong_callingMethodsBeforeInit() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethodFor( tc.getTestCase(), servlet, new GenericMethod(FakeServlet.class.getDeclaredMethod("foo"), FakeServlet.class), 1); // initializing bounding variable method cannot be called here after "foo" is called on the // bounded variable factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 2, 0); Assert.assertEquals(3, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testInitializingBoundedVariable_wrong_inputInOtherMethodBeforeInit() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( ConstraintVerifierTest.class.getDeclaredMethod("takeServletAsInput", FakeServlet.class), ConstraintVerifierTest.class), 1, 0); // initializing bounding variable method cannot be called here after the bounded variable has // been used as input in some other method factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 2, 0); Assert.assertEquals(3, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testAfter() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); // this method has an "after" constraint on initServlet factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getRequest"), EvoServletState.class), 0, 0); Assert.assertEquals(1, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); VariableReference con = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("initServlet", Servlet.class), EvoServletState.class), 1, 0); Assert.assertEquals(3, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testTwoIntsWeakMutation() throws NoSuchMethodException, SecurityException, ClassNotFoundException, ConstructionFailedException { Properties.TARGET_CLASS = IntExampleWithNoElse.class.getCanonicalName(); TestChromosome test1 = new TestChromosome(); test1.setTestCase(getTwoIntTest(1, 1000)); TestChromosome test2 = new TestChromosome(); test2.setTestCase(getTwoIntTest(0, 0)); TestSuiteChromosome suite = new TestSuiteChromosome(); WeakMutationSuiteFitness fitness = new WeakMutationSuiteFitness(); suite.addTest(test1); suite.addTest(test2); Properties.P_TEST_CHANGE = 1.0; Properties.P_TEST_DELETE = 0.0; Properties.P_TEST_INSERT = 0.0; Properties.PRIMITIVE_POOL = 0.0; double oldFitness = fitness.getFitness(suite); int notChanged = 0; for (int i = 0; i < 10000; i++) { TestChromosome testNew = (TestChromosome) test1.clone(); testNew.mutate(); if (testNew.isChanged()) { suite.deleteTest(test1); suite.addTest(testNew); double newFitness = fitness.getFitness(suite); if (newFitness < oldFitness) { test1 = testNew; oldFitness = newFitness; System.out.println( "" + i + ":" + ((IntPrimitiveStatement) test1.getTestCase().getStatement(1)).getValue()); System.out.println( " " + ((IntPrimitiveStatement) test1.getTestCase().getStatement(2)).getValue()); if (newFitness == 0.0) { System.out.println("Iterations: " + i); System.out.println("Not changed: " + notChanged); break; } } else { suite.deleteTest(testNew); suite.addTest(test1); fitness.getFitness(suite); } } else { notChanged++; } } System.out.println("Fitness: " + fitness.getFitness(suite)); System.out.println("Test suite: " + suite); assertEquals(0.0, fitness.getFitness(suite), 0.1F); }
@Test public void testExcludeMethod() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); // 'reset' is a method that shouldn't be used in a test factory.addMethod( tc.getTestCase(), new GenericMethod(EvoServletState.class.getDeclaredMethod("reset"), EvoServletState.class), 0, 0); Assert.assertEquals(tc.getTestCase().toCode(), 1, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testAtMostOnce() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("initServlet", Servlet.class), EvoServletState.class), 1, 0); // 2 different methods that can be used at most once factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getRequest"), EvoServletState.class), 2, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getResponse"), EvoServletState.class), 3, 0); Assert.assertEquals(4, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); // add an invalid new call factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getResponse"), EvoServletState.class), 4, 0); Assert.assertEquals(5, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); // check should fail }
@Test public void testPostConstructIssue() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // this will also add a statement for the Class factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class, Class.class), Injector.class), 1, 0); Assert.assertEquals(3, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); boolean mutated = tc.deleteStatement(factory, 2); Assert.assertFalse(mutated); // should fail to delete the post construct Assert.assertEquals(3, tc.size()); Assert.assertFalse(ConstraintVerifier.canDelete(tc.getTestCase(), 1)); mutated = tc.deleteStatement(factory, 1); Assert.assertFalse( mutated); // eliminating the Class.class var should fail as well, as post construct accepts // no null Assert.assertEquals(3, tc.size()); mutated = tc.deleteStatement(factory, 0); Assert.assertTrue(mutated); // eliminating the servlet is fine Assert.assertEquals(1, tc.size()); // tricky, as Class.class is not bounded to the servlet Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testCanDelete() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // initializing bounding variable method called directly after the new factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 1, 0); Assert.assertEquals(2, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); Assert.assertTrue( ConstraintVerifier.canDelete(tc.getTestCase(), 0)); // bounded variable can be deleted Assert.assertFalse( ConstraintVerifier.canDelete( tc.getTestCase(), 1)); // method using bounded variable should not be deleted boolean mutated = tc.deleteStatement(factory, 1); Assert.assertFalse(mutated); // should fail Assert.assertEquals(2, tc.size()); mutated = tc.deleteStatement(factory, 0); Assert.assertTrue(mutated); Assert.assertEquals( 0, tc.size()); // deleting first statement should have had effect of removing the second as // well }
@Test public void testHasAnyOnlyForAssertionMethod() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference req = factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getRequest"), EvoServletState.class), 0, 0); Assert.assertEquals(tc.getTestCase().toCode(), 1, tc.size()); Assert.assertFalse(ConstraintVerifier.hasAnyOnlyForAssertionMethod(tc.getTestCase())); // this method should be only for assertions factory.addMethodFor( tc.getTestCase(), req, new GenericMethod( EvoHttpServletRequest.class.getDeclaredMethod("isAsyncStarted"), EvoHttpServletRequest.class), 1); Assert.assertEquals(tc.getTestCase().toCode(), 2, tc.size()); Assert.assertTrue(ConstraintVerifier.hasAnyOnlyForAssertionMethod(tc.getTestCase())); }
@Test public void testNoDirectInsertion() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); GenericMethod gm = new GenericMethod( ConstraintVerifierTest.class.getDeclaredMethod("noDirect", null), ConstraintVerifierTest.class); // should not be possible to insert it int pos = ConstraintVerifier.getAValidPositionForInsertion(gm, tc.getTestCase(), 0); Assert.assertTrue(pos < 0); }
@Test public void testBaseTest() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); factory.addConstructor( tc.getTestCase(), new GenericConstructor(Object.class.getConstructor(), Object.class), 0, 0); Assert.assertEquals(1, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testEvoSuiteClassExclude() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); // shouldn't be able to instantiate EvoServletConfig directly factory.addConstructor( tc.getTestCase(), new GenericConstructor(EvoServletConfig.class.getConstructor(), EvoServletConfig.class), 0, 0); Assert.assertEquals(1, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testInitializingBoundedVariable_wrong_noConstructor() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); factory.addMethod( tc.getTestCase(), new GenericMethod( ConstraintVerifierTest.class.getDeclaredMethod("getAFakeServletInstance"), ConstraintVerifierTest.class), 0, 0); // initializing bounding variable method called on instance not generated with new factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 1, 0); Assert.assertEquals(2, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testDeleteAfter() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); // get a var for EvoHttpServletRequest VariableReference req = factory.addMethod( tc.getTestCase(), new GenericMethod( ConstraintVerifierTest.class.getDeclaredMethod("getNullEvoHttpServletRequest"), ConstraintVerifierTest.class), 0, 0); // make it a POST factory.addMethod( tc.getTestCase(), new GenericMethod( EvoHttpServletRequest.class.getDeclaredMethod("asPOST"), EvoHttpServletRequest.class), 1, 0); // now add a call to 'asMultipartFormData' which does depend on POST factory.addMethod( tc.getTestCase(), new GenericMethod( EvoHttpServletRequest.class.getDeclaredMethod("asMultipartFormData"), EvoHttpServletRequest.class), 2, 0); Assert.assertEquals(3, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); // deleting the last one should be fine, but not the POST, as asMultipartFormData has an 'after' // dependency on it Assert.assertTrue(ConstraintVerifier.canDelete(tc.getTestCase(), 2)); Assert.assertFalse( ConstraintVerifier.canDelete( tc.getTestCase(), 1)); // should not be able to delete POST directly // what about the first statement where the var is obtained? that should be valid to delete Assert.assertTrue(ConstraintVerifier.canDelete(tc.getTestCase(), 0)); boolean mutated = tc.deleteStatement(factory, 1); Assert.assertFalse(mutated); // should fail to delete POST Assert.assertEquals(3, tc.size()); mutated = tc.deleteStatement(factory, 0); Assert.assertTrue(mutated); Assert.assertEquals(0, tc.size()); // should end up deleting everything }
@Test public void testExcludeOthers() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("initServlet", Servlet.class), EvoServletState.class), 1, 0); VariableReference req = factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getRequest"), EvoServletState.class), 2, 0); factory.addMethodFor( tc.getTestCase(), req, new GenericMethod( EvoHttpServletRequest.class.getDeclaredMethod("asGET"), EvoHttpServletRequest.class), 3); Assert.assertEquals(tc.getTestCase().toCode(), 4, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); // once it is set as GET, we should not be able to change it to POST factory.addMethodFor( tc.getTestCase(), req, new GenericMethod( EvoHttpServletRequest.class.getDeclaredMethod("asPOST"), EvoHttpServletRequest.class), 4); Assert.assertEquals(tc.getTestCase().toCode(), 5, tc.size()); Assert.assertFalse(ConstraintVerifier.verifyTest(tc)); }
@Test public void testNoNullInputs_nullString() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("initServlet", Servlet.class), EvoServletState.class), 1, 0); // shouldn't be able to pass it to createDispatcher StringPrimitiveStatement foo = new StringPrimitiveStatement(tc.getTestCase(), null); tc.getTestCase().addStatement(foo); VariableReference con = factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getConfiguration"), EvoServletState.class), 3, 0); factory.addMethodFor( tc.getTestCase(), con, new GenericMethod( EvoServletConfig.class.getDeclaredMethod("createDispatcher", String.class), EvoServletConfig.class), 4); /* even if "foo" is null and we have the P of object reuse to 1, still "foo" will not be used, as "null" constraint is always enforced */ Assert.assertEquals(tc.getTestCase().toCode(), 6, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testNoNullInputs_notNull() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("initServlet", Servlet.class), EvoServletState.class), 1, 0); StringPrimitiveStatement foo = new StringPrimitiveStatement(tc.getTestCase(), "foo"); tc.getTestCase().addStatement(foo); VariableReference con = factory.addMethod( tc.getTestCase(), new GenericMethod( EvoServletState.class.getDeclaredMethod("getConfiguration"), EvoServletState.class), 3, 0); factory.addMethodFor( tc.getTestCase(), con, new GenericMethod( EvoServletConfig.class.getDeclaredMethod("createDispatcher", String.class), EvoServletConfig.class), 4); Assert.assertEquals(5, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); }
@Test public void testSimpleInt() throws NoSuchMethodException, SecurityException, ClassNotFoundException, ConstructionFailedException { Properties.TARGET_CLASS = TrivialInt.class.getCanonicalName(); TestChromosome test1 = new TestChromosome(); test1.setTestCase(getIntTest(2938, -1000000)); TestChromosome test2 = (TestChromosome) test1.clone(); TestSuiteChromosome suite = new TestSuiteChromosome(); BranchCoverageSuiteFitness fitness = new BranchCoverageSuiteFitness(); assertEquals(4.0, fitness.getFitness(suite), 0.0F); suite.addTest(test1); assertEquals(1.0, fitness.getFitness(suite), 0.0F); suite.addTest(test2); assertEquals(1.0, fitness.getFitness(suite), 0.01F); // 0.99... Class<?> sut = TestGenerationContext.getInstance() .getClassLoaderForSUT() .loadClass(Properties.TARGET_CLASS); Method m = sut.getMethod("testMe", new Class<?>[] {int.class}); GenericMethod method = new GenericMethod(m, sut); TestCluster.getInstance().addTestCall(method); Properties.P_TEST_CHANGE = 0.0; Properties.P_TEST_DELETE = 1.0; Properties.P_TEST_INSERT = 0.0; double oldFitness = suite.getFitness(); int notChanged = 0; for (int i = 0; i < 100; i++) { TestChromosome testNew = (TestChromosome) test1.clone(); testNew.mutate(); if (testNew.isChanged()) { suite.deleteTest(test1); suite.addTest(testNew); System.out.println(testNew.getTestCase().toCode()); double newFitness = fitness.getFitness(suite); if (newFitness < oldFitness) { System.out.println("Improved: " + newFitness); test1 = testNew; oldFitness = newFitness; System.out.println( "" + i + ":" + ((IntPrimitiveStatement) test1.getTestCase().getStatement(1)).getValue()); if (newFitness == 0.0) { System.out.println("Iterations: " + i); System.out.println("Not changed: " + notChanged); break; } } else { System.out.println("Not improved: " + newFitness); suite.deleteTest(testNew); suite.addTest(test1); fitness.getFitness(suite); } } else { notChanged++; } } System.out.println("Fitness: " + fitness.getFitness(suite)); System.out.println("Test suite: " + suite); assertEquals(0.0, fitness.getFitness(suite), 0.1F); }
@Test public void testDelete_multipleVarsThatCouldBeReused() throws Exception { TestChromosome tc = new TestChromosome(); TestFactory factory = TestFactory.getInstance(); VariableReference servlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 0, 0); // initializing bounding variable method called directly after the new factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 1, 0); // now do it again VariableReference secondServlet = factory.addConstructor( tc.getTestCase(), new GenericConstructor(FakeServlet.class.getDeclaredConstructor(), FakeServlet.class), 2, 0); factory.addMethod( tc.getTestCase(), new GenericMethod( Injector.class.getDeclaredMethod("executePostConstruct", Object.class), Injector.class), 3, 0); MethodStatement mt = (MethodStatement) tc.getTestCase().getStatement(3); // be sure it is using the second servlet mt.replace(servlet, secondServlet); Assert.assertEquals(4, tc.size()); Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); Assert.assertTrue( ConstraintVerifier.canDelete(tc.getTestCase(), 0)); // bounded variable can be deleted Assert.assertFalse( ConstraintVerifier.canDelete( tc.getTestCase(), 1)); // method using bounded variable should not be deleted Assert.assertTrue( ConstraintVerifier.canDelete(tc.getTestCase(), 2)); // bounded variable can be deleted Assert.assertFalse( ConstraintVerifier.canDelete( tc.getTestCase(), 3)); // method using bounded variable should not be deleted boolean mutated = tc.deleteStatement(factory, 2); Assert.assertTrue(mutated); /* deleting the bounded variable in position 2 should lead to also delete the initializing variable in 3, and not end up with 3 re-using 0 */ Assert.assertTrue(ConstraintVerifier.verifyTest(tc)); Assert.assertEquals(2, tc.size()); }