@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 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 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()); }