public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2}, new Class<?>[]{t0,t1,t2}); }
/** * Use reflection to set the given field * * @param klass * @param instance null if field is static * @param fieldName * @param value * @param <T> the class type * @throws IllegalArgumentException if klass or fieldName are null * @throws FalsePositiveException if the the field does not exist anymore (eg due to refactoring) */ public static <T> void setVariable(Class<T> klass, T instance, String fieldName, Object value) throws IllegalArgumentException, FalsePositiveException { setVariable(klass,instance,fieldName,value,null); }
@Test public void testSetField_error(){ PrivateAccess.setShouldNotFailTest(true); PrivateAccess.setVariable(FooFields.class, null, "a non-existing field", 42); Assert.fail(); // this should never be reached, as failed "Assumption" inside setVariable }
@Test public void testMethod_error() throws Throwable { PrivateAccess.setShouldNotFailTest(true); PrivateAccess.callMethod(FooMethods.class, null,"a non-existing method", new Object[0], new Class<?>[0]); Assert.fail(); }
/** * Call the default constructor of the class under test. * This is useful to avoid low coverage due to private constructors in final * classes used to prevent instantiating them (eg those classes only have * static methods) * * @throws Throwable */ @Constraints(atMostOnce = true, notMutable = true) public static Object callDefaultConstructorOfTheClassUnderTest() throws Throwable{ Class<?> cut = Thread.currentThread().getContextClassLoader().loadClass(RuntimeSettings.className); return callDefaultConstructor(cut); }
@After public void tearDown(){ PrivateAccess.setShouldNotFailTest(true); }
public PrivateMethodStatement(TestCase tc, Class<?> klass, Method method, VariableReference callee, List<VariableReference> params, boolean isStatic) { super( tc, new GenericMethod(PrivateAccess.getCallMethod(params.size()),PrivateAccess.class), null, //it is static getReflectionParams(tc,klass,method,callee,params) ); reflectedMethod = new GenericMethod(method, klass); isStaticMethod = isStatic; List<GenericClass> parameterTypes = new ArrayList<>(); parameterTypes.add(new GenericClass(klass)); this.method.setTypeParameters(parameterTypes); }
@Test public void testSetField_fail_on_error(){ PrivateAccess.setShouldNotFailTest(false); try { PrivateAccess.setVariable(FooFields.class, null, "a non-existing field", 42); Assert.fail(); } catch (FalsePositiveException e){ Assert.fail(); } catch (RuntimeException e){ //Ok, expected } finally { PrivateAccess.setShouldNotFailTest(true); } }
@Test public void testMethod_fail_on_error(){ PrivateAccess.setShouldNotFailTest(false); try { PrivateAccess.callMethod(FooMethods.class, null, "a non-existing method", new Object[0], new Class<?>[0]); Assert.fail(); } catch (FalsePositiveException e){ Assert.fail(); } catch (Throwable e){ //Ok, expected } finally { PrivateAccess.setShouldNotFailTest(true); } }
@Test public void testPrivateConstructor() throws Throwable{ FooConstructor.counter = 0; PrivateAccess.callDefaultConstructor(FooConstructor.class); assertTrue(FooConstructor.counter > 0); }
@Before public void init(){ PrivateAccess.setShouldNotFailTest(false); }
public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2, Object i3, Class<?> t3, Object i4, Class<?> t4 , Object i5, Class<?> t5, Object i6, Class<?> t6, Object i7, Class<?> t7, Object i8, Class<?> t8, Object i9, Class<?> t9 , Object i10, Class<?> t10,Object i11, Class<?> t11,Object i12, Class<?> t12,Object i13, Class<?> t13,Object i14, Class<?> t14 , Object i15, Class<?> t15) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15}, new Class<?>[]{t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15}); }
@Constraints(noNullInputs = true, notMutable = true, noDirectInsertion = true) public static <T> void inject(@BoundInputVariable(initializer = true, atMostOnceWithSameParameters = true) T instance, Class<?> klass, String fieldName, Object value) throws IllegalArgumentException { try { PrivateAccess.setVariable(klass, instance, fieldName, value, InjectionList.getList()); } catch (FalsePositiveException e){ /* do not abort the test if failed to add dependency injection. This is quite different from private access: a PA does have effect on test, otherwise minimization would had removed them. But a dependency injection might have no impact whatsoever */ } }
public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2,Object i3, Class<?> t3,Object i4, Class<?> t4 ,Object i5, Class<?> t5,Object i6, Class<?> t6,Object i7, Class<?> t7,Object i8, Class<?> t8) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2,i3,i4,i5,i6,i7,i8}, new Class<?>[]{t0,t1,t2,t3,t4,t5,t6,t7,t8}); }
@Test public void testSetField_serialVersionUID(){ try { //it should fail PrivateAccess.setVariable(FooFields.class, null, "serialVersionUID", 42l); Assert.fail(); } catch (IllegalArgumentException e){ //expected } }
public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2, Object i3, Class<?> t3, Object i4, Class<?> t4 , Object i5, Class<?> t5, Object i6, Class<?> t6, Object i7, Class<?> t7, Object i8, Class<?> t8, Object i9, Class<?> t9 , Object i10, Class<?> t10,Object i11, Class<?> t11) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11}, new Class<?>[]{t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11}); }
@Test public void testSetField_static(){ PrivateAccess.setVariable(FooFields.class,null,"n",42); Assert.assertEquals(42, FooFields.getN()); }
public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2, Object i3, Class<?> t3, Object i4, Class<?> t4 , Object i5, Class<?> t5, Object i6, Class<?> t6, Object i7, Class<?> t7, Object i8, Class<?> t8, Object i9, Class<?> t9 , Object i10, Class<?> t10,Object i11, Class<?> t11,Object i12, Class<?> t12,Object i13, Class<?> t13,Object i14, Class<?> t14 , Object i15, Class<?> t15,Object i16, Class<?> t16,Object i17, Class<?> t17) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16,i17}, new Class<?>[]{t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17}); }
@Test public void testSetField_instance(){ FooFields foo = new FooFields(); PrivateAccess.setVariable(FooFields.class,foo,"s","bar"); Assert.assertEquals("bar",foo.getS()); }
public static <T> Object callMethod(Class<T> klass, T instance, String methodName , Object i0, Class<?> t0, Object i1, Class<?> t1, Object i2, Class<?> t2, Object i3, Class<?> t3, Object i4, Class<?> t4 , Object i5, Class<?> t5, Object i6, Class<?> t6, Object i7, Class<?> t7, Object i8, Class<?> t8, Object i9, Class<?> t9 , Object i10, Class<?> t10,Object i11, Class<?> t11,Object i12, Class<?> t12,Object i13, Class<?> t13,Object i14, Class<?> t14 , Object i15, Class<?> t15,Object i16, Class<?> t16,Object i17, Class<?> t17,Object i18, Class<?> t18) throws Throwable { return callMethod(klass,instance,methodName,new Object[]{i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16,i17,i18}, new Class<?>[]{t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18}); }