/** * Matches an array of parameters to an array of instances. * * @return matches or not * @see #exactMatch(Class[], Object[]) */ public static boolean exactMatch(final Parameter[] parameters, final Object[] args) { return exactMatch(classesFromParameters(parameters), args); }
/** * Constructs a context for MethodMatchers. * * @param method current method. * @param arguments user arguments. * @param testContext current test context. * @param testResult current test results. */ public MethodMatcherContext( final Method method, final Object[] arguments, final ITestContext testContext, final ITestResult testResult) { this.method = method; this.methodParameter = ReflectionRecipes.getMethodParameters(method); this.arguments = arguments; this.testContext = testContext; this.testResult = testResult; }
/** * @return matches or not * @see #matchArrayEnding(Class[], Object[]) */ public static boolean matchArrayEnding(final Parameter[] parameters, final Object[] param) { return matchArrayEnding(classesFromParameters(parameters), param); }
/** * Matches an array of parameters to an array of instances. * * @return matches or not * @see #lenientMatch(Class[], Object[]) */ public static boolean lenientMatch(final Parameter[] parameters, final Object[] args) { return lenientMatch(classesFromParameters(parameters), args); }
@Test(dataProvider = "exactMatchDP") public void exactMatchTest(final Object[][] expected, @NoInjection final Method method) { if (expected != null) { final Parameter[] methodParameters = ReflectionRecipes.getMethodParameters(method); Assert.assertNotNull(methodParameters); final Parameter[] filteredParameters = ReflectionRecipes.filter(methodParameters, InjectableParameter.Assistant.ALL_INJECTS); Assert.assertNotNull(filteredParameters); for (final Object[] expect : expected) { Assert.assertNotNull(expect); Assert.assertEquals(expect.length, 2); Assert.assertNotNull(expect[0]); Assert.assertTrue(expect[0] instanceof Object[]); Assert.assertNotNull(expect[1]); Assert.assertTrue(expect[1] instanceof Boolean); Assert.assertEquals( ReflectionRecipes.exactMatch(filteredParameters, (Object[]) expect[0]), expect[1] ); } } }
@Test(dataProvider = "matchArrayEndingDP") public void matchArrayEndingTest(final Object[][] expected, @NoInjection final Method method) { if (expected != null) { final Parameter[] methodParameters = ReflectionRecipes.getMethodParameters(method); Assert.assertNotNull(methodParameters); final Parameter[] filteredParameters = ReflectionRecipes.filter(methodParameters, InjectableParameter.Assistant.ALL_INJECTS); Assert.assertNotNull(filteredParameters); for (final Object[] expect : expected) { Assert.assertNotNull(expect); Assert.assertEquals(expect.length, 2); Assert.assertNotNull(expect[0]); Assert.assertTrue(expect[0] instanceof Object[]); Assert.assertNotNull(expect[1]); Assert.assertTrue(expect[1] instanceof Boolean); Assert.assertEquals( ReflectionRecipes.matchArrayEnding(filteredParameters, (Object[]) expect[0]), expect[1] ); } } }
/** * @return An array of parameters suitable to invoke this method, possibly * picked from the property file */ private static Object[] createParametersForMethod(Method method, Class<?>[] parameterTypes, String[] optionalValues, String methodAnnotation, String[] parameterNames, MethodParameters params, XmlSuite xmlSuite) { if (parameterTypes.length == 0) { return new Object[0]; } checkParameterTypes(method.getName(), parameterTypes, methodAnnotation, parameterNames); List<Object> vResult = Lists.newArrayList(); List<Object> consParams = createParams(method.getName(), "method", methodAnnotation, parameterTypes, optionalValues, parameterNames, params, xmlSuite); if (canInject(methodAnnotation)) { Parameter[] paramsArray = ReflectionRecipes.getMethodParameters(method); Object[] inject = ReflectionRecipes.inject(paramsArray, InjectableParameter.Assistant.ALL_INJECTS, consParams.toArray(new Object[consParams.size()]), params.currentTestMethod, params.context, params.testResult); if (inject != null) { vResult.addAll(Arrays.asList(inject)); } } else { vResult.addAll(consParams); } return vResult.toArray(new Object[vResult.size()]); }
private static Object[] createParametersForConstructor(Constructor constructor, Class<?>[] parameterTypes, String[] optionalValues, String methodAnnotation, String[] parameterNames, MethodParameters params, XmlSuite xmlSuite) { if (parameterTypes.length == 0) { return new Object[0]; } checkParameterTypes(constructor.getName(), parameterTypes, methodAnnotation, parameterNames); List<Object> vResult = Lists.newArrayList(); if (canInject(methodAnnotation)) { Parameter[] paramsArray = ReflectionRecipes.getConstructorParameters(constructor); Object[] inject = ReflectionRecipes.inject(paramsArray, InjectableParameter.Assistant.ALL_INJECTS, new Object[0], constructor, params.context, params.testResult); if (inject != null) { vResult.addAll(Arrays.asList(inject)); } } List<Object> consParams = createParams(constructor.getName(), "constructor", methodAnnotation, parameterTypes, optionalValues, parameterNames, params, xmlSuite); vResult.addAll(consParams); return vResult.toArray(new Object[vResult.size()]); }
private static boolean canInject(final Parameter parameter, final InjectableParameter injectableParameter) { boolean canInject = false; if (parameter != null ) { final boolean inject = !parameter.isAnnotationPresent(NoInjection.class); switch (injectableParameter) { case CURRENT_TEST_METHOD: final boolean isMethod = isOrExtends(Method.class, parameter.getType()); canInject = inject && isMethod; break; case ITEST_CONTEXT: canInject = inject && isOrImplementsInterface(ITestContext.class, parameter.getType()); break; case ITEST_RESULT: canInject = inject && isOrImplementsInterface(ITestResult.class, parameter.getType()); break; case XML_TEST: canInject = inject && isOrExtends(XmlTest.class, parameter.getType()); break; default: canInject = false; break; } } return canInject; }
private static Parameter[] extractParameters(ConstructorOrMethod method) { if (method.getMethod() != null) { return ReflectionRecipes.getMethodParameters(method.getMethod()); } return ReflectionRecipes.getConstructorParameters(method.getConstructor()); }
@Test(dataProvider = "notTestContexts") public void testNegativeCaseIsOrImplementsInterface(final Class<?> clazz) { Assert.assertFalse(ReflectionRecipes.isOrImplementsInterface(ITestContext.class, clazz)); }
@Test(dataProvider = "methodInputParamArgsPair") public void testInject(final Parameter[] parameters, final Object[] args) { System.out.println("In: " + Arrays.asList(parameters)); System.out.println("args: " + Arrays.asList(args)); final Object[] injectedArgs = ReflectionRecipes.inject( parameters, InjectableParameter.Assistant.ALL_INJECTS, args, (Method)null, null, null ); System.out.println("injectedArgs: " + Arrays.asList(injectedArgs)); Assert.assertEquals(injectedArgs.length, parameters.length); }
@Test(dataProvider = "methodInputParameters") public void testFilters(final Parameter[] parameters) { System.out.println("In: " + Arrays.asList(parameters)); final Parameter[] parameters1 = ReflectionRecipes.filter(parameters, InjectableParameter.Assistant.ALL_INJECTS); System.out.println("Out: " + Arrays.asList(parameters1)); Assert.assertEquals(parameters1.length, 2); Assert.assertEquals(parameters1[0].getType(), int.class); Assert.assertEquals(parameters1[1].getType(), Boolean.class); }
/** * {@inheritDoc} * * @see ReflectionRecipes#matchArrayEnding(Class[], Object[]) */ @Override protected boolean match(final Parameter[] parameters, final Object[] arguments) { return ReflectionRecipes.matchArrayEnding(parameters, getContext().getArguments()); }
/** * {@inheritDoc} */ @Override protected boolean match(final Parameter[] parameters, final Object[] arguments) { return ReflectionRecipes.exactMatch(parameters, getContext().getArguments()); }
/** * Extracts method parameters. * * @param method any valid method. * @return extracted method parameters. */ public static Parameter[] getMethodParameters(final Method method) { if (method == null) { return new Parameter[]{}; } return getParameters(method.getParameterTypes(), method.getParameterAnnotations()); }
boolean omit = false; for (final InjectableParameter injectableParameter : filters) { omit = canInject(parameter, injectableParameter); switch (injectableParameter) { case CURRENT_TEST_METHOD:
static String generateMessage(final String message, final Constructor constructor, final Object[] args) { Parameter[] parameter = null; String name = null; if (constructor != null) { parameter = ReflectionRecipes.getConstructorParameters(constructor); name = constructor.getName(); } return generateMessage(message, name, "Constructor", parameter, args); }
/** * {@inheritDoc} */ @Override protected Object[] matchingArguments(final Parameter[] parameters, final Object[] arguments) { final Class<?>[] classes = ReflectionRecipes.classesFromParameters(parameters); final Object[] objects = new Object[classes.length]; final Class<?> componentType = classes[classes.length - 1].getComponentType(); final Object array = Array.newInstance(componentType, arguments.length - classes.length + 1); System.arraycopy(arguments, 0, objects, 0, classes.length - 1); int j = 0; for (int i = classes.length - 1; i < arguments.length; i++, j++) { Array.set(array, j, arguments[i]); } objects[classes.length - 1] = array; return objects; }
Parameter[] paramsArray = ReflectionRecipes.getConstructorParameters(constructor); Object[] inject = ReflectionRecipes.inject( paramsArray, InjectableParameter.Assistant.ALL_INJECTS,