static boolean isPrimitiveOrNullable(Parameter param) { return param.getType().getRawType().isPrimitive() || isNullable(param); }
private Object[] buildParamList(Invokable<?, ?> invokable, int indexOfParamToSetToNull) { ImmutableList<Parameter> params = invokable.getParameters(); Object[] args = new Object[params.size()]; for (int i = 0; i < args.length; i++) { Parameter param = params.get(i); if (i != indexOfParamToSetToNull) { args[i] = getDefaultValue(param.getType()); Assert.assertTrue( "Can't find or create a sample instance for type '" + param.getType() + "'; please provide one using NullPointerTester.setDefault()", args[i] != null || isNullable(param)); } } return args; }
private List<Object> getDummyArguments(Invokable<?, ?> invokable) throws ParameterNotInstantiableException { List<Object> args = Lists.newArrayList(); for (Parameter param : invokable.getParameters()) { if (isNullable(param)) { args.add(null); continue; } Object defaultValue = getDummyValue(param.getType()); if (defaultValue == null) { throw new ParameterNotInstantiableException(param); } args.add(defaultValue); } return args; }
public <T extends List<String>> void testMethod_parameterTypes() throws NoSuchMethodException { Method setMethod = List.class.getMethod("set", int.class, Object.class); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.method(setMethod); ImmutableList<Parameter> params = invokable.getParameters(); assertEquals(2, params.size()); assertEquals(TypeToken.of(int.class), params.get(0).getType()); assertEquals(TypeToken.of(String.class), params.get(1).getType()); }
private static @Nullable Object generateDummyArg(Parameter param, FreshValueGenerator generator) throws ParameterNotInstantiableException { if (isNullable(param)) { return null; } Object arg = generator.generateFresh(param.getType()); if (arg == null) { throw new ParameterNotInstantiableException(param); } return arg; }
public <T extends Container<String>> void testConstructor_parameterTypes() throws NoSuchMethodException { @SuppressWarnings("rawtypes") // Reflection API skew Constructor<Container> constructor = Container.class.getConstructor(Object.class); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.constructor(constructor); ImmutableList<Parameter> params = invokable.getParameters(); assertEquals(1, params.size()); assertEquals(TypeToken.of(String.class), params.get(0).getType()); }
public void testInnerClassWithGenericConstructorParameter() { Constructor<?> constructor = InnerWithGenericConstructorParameter.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(2, invokable.getParameters().size()); assertEquals(new TypeToken<Iterable<String>>() {}, invokable.getParameters().get(0).getType()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(1).getType()); }
public void testLocalClassWithGenericConstructorParameter() throws Exception { class LocalWithGenericConstructorParameter { @SuppressWarnings("unused") // called by reflection LocalWithGenericConstructorParameter(Iterable<String> it, String s) {} } Constructor<?> constructor = LocalWithGenericConstructorParameter.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(2, invokable.getParameters().size()); assertEquals(new TypeToken<Iterable<String>>() {}, invokable.getParameters().get(0).getType()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(1).getType()); }
public void testInnerClassWithAnnotatedConstructorParameter() { Constructor<?> constructor = InnerWithAnnotatedConstructorParameter.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(1, invokable.getParameters().size()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType()); }
public void testLocalClassWithAnnotatedConstructorParameter() throws Exception { class LocalWithAnnotatedConstructorParameter { @SuppressWarnings("unused") // called by reflection LocalWithAnnotatedConstructorParameter(@Nullable String s) {} } Constructor<?> constructor = LocalWithAnnotatedConstructorParameter.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(1, invokable.getParameters().size()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType()); }
private static <T> void callAllPublicMethods(TypeToken<T> type, T object) throws InvocationTargetException { for (Method method : type.getRawType().getMethods()) { if ((method.getModifiers() & STATIC) != 0) { continue; } ImmutableList<Parameter> parameters = type.method(method).getParameters(); Object[] args = new Object[parameters.size()]; for (int i = 0; i < parameters.size(); i++) { args[i] = getDefaultValue(parameters.get(i).getType()); } try { try { method.invoke(object, args); } catch (InvocationTargetException ex) { try { throw ex.getCause(); } catch (UnsupportedOperationException unsupported) { // this is a legit exception } } } catch (Throwable cause) { throw new InvocationTargetException( cause, method + " with args: " + Arrays.toString(args)); } } } }
public void testInnerClassWithOneParameterConstructor() { Constructor<?> constructor = InnerWithOneParameterConstructor.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(1, invokable.getParameters().size()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType()); }
public void testLocalClassWithOneParameterConstructor() throws Exception { final int i = 1; final String s = "hello world"; class LocalWithOneParameterConstructor { @SuppressWarnings("unused") // called by reflection public LocalWithOneParameterConstructor(String x) { System.out.println(s + i); } } Constructor<?> constructor = LocalWithOneParameterConstructor.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(1, invokable.getParameters().size()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType()); }
public void testWildcardCaptured_wildcardWithExplicitBound() throws Exception { TypeToken<Holder<? extends Number>> type = new TypeToken<Holder<? extends Number>>() {}; ImmutableList<Parameter> parameters = type.method(Holder.class.getDeclaredMethod("setList", List.class)).getParameters(); assertThat(parameters).hasSize(1); TypeToken<?> parameterType = parameters.get(0).getType(); Type[] typeArgs = ((ParameterizedType) parameterType.getType()).getActualTypeArguments(); assertThat(typeArgs).asList().hasSize(1); TypeVariable<?> captured = (TypeVariable<?>) typeArgs[0]; assertThat(captured.getBounds()).asList().containsExactly(Number.class); assertThat(new TypeToken<List<? extends Number>>() {}.isSupertypeOf(parameterType)).isTrue(); }
public void testWildcardCaptured_methodParameter_upperBound() throws Exception { TypeToken<Holder<?>> type = new TypeToken<Holder<?>>() {}; ImmutableList<Parameter> parameters = type.method(Holder.class.getDeclaredMethod("setList", List.class)).getParameters(); assertThat(parameters).hasSize(1); TypeToken<?> parameterType = parameters.get(0).getType(); assertEquals(List.class, parameterType.getRawType()); assertFalse( parameterType.getType().toString(), parameterType.isSupertypeOf(new TypeToken<List<Integer>>() {})); }
public void testWildcardCaptured_wildcardWithImplicitBound() throws Exception { TypeToken<Holder<?>> type = new TypeToken<Holder<?>>() {}; ImmutableList<Parameter> parameters = type.method(Holder.class.getDeclaredMethod("setList", List.class)).getParameters(); assertThat(parameters).hasSize(1); TypeToken<?> parameterType = parameters.get(0).getType(); Type[] typeArgs = ((ParameterizedType) parameterType.getType()).getActualTypeArguments(); assertThat(typeArgs).asList().hasSize(1); TypeVariable<?> captured = (TypeVariable<?>) typeArgs[0]; assertThat(captured.getBounds()).asList().containsExactly(Object.class); assertThat(new TypeToken<List<?>>() {}.isSupertypeOf(parameterType)).isTrue(); }
public void testInstanceMethod_parameters() throws Exception { Invokable<?, ?> delegate = Prepender.method("prepend", Iterable.class); ImmutableList<Parameter> parameters = delegate.getParameters(); assertEquals(1, parameters.size()); assertEquals(new TypeToken<Iterable<String>>() {}, parameters.get(0).getType()); assertThat(parameters.get(0).getAnnotations()).isEmpty(); new EqualsTester().addEqualityGroup(parameters.get(0)).testEquals(); }
public void testConstructor_parameters() throws Exception { Invokable<?, Prepender> delegate = Prepender.constructor(String.class, int.class); ImmutableList<Parameter> parameters = delegate.getParameters(); assertEquals(2, parameters.size()); assertEquals(String.class, parameters.get(0).getType().getType()); assertTrue(parameters.get(0).isAnnotationPresent(NotBlank.class)); assertEquals(int.class, parameters.get(1).getType().getType()); assertFalse(parameters.get(1).isAnnotationPresent(NotBlank.class)); new EqualsTester() .addEqualityGroup(parameters.get(0)) .addEqualityGroup(parameters.get(1)) .testEquals(); }
public void testStaticMethod_parameters() throws Exception { Invokable<?, ?> delegate = Prepender.method("prepend", String.class, Iterable.class); ImmutableList<Parameter> parameters = delegate.getParameters(); assertEquals(2, parameters.size()); assertEquals(String.class, parameters.get(0).getType().getType()); assertTrue(parameters.get(0).isAnnotationPresent(NotBlank.class)); assertEquals(new TypeToken<Iterable<String>>() {}, parameters.get(1).getType()); assertFalse(parameters.get(1).isAnnotationPresent(NotBlank.class)); new EqualsTester() .addEqualityGroup(parameters.get(0)) .addEqualityGroup(parameters.get(1)) .testEquals(); }