protected AbstractDataProviderArgumentProvider() { this(new DataConverter()); }
private List<Object[]> convert(Iterable<?> data, boolean isVarargs, Class<?>[] parameterTypes, ConverterContext context) { List<Object[]> result = new ArrayList<Object[]>(); for (Object arguments : data) { if (arguments != null && Iterable.class.isAssignableFrom(arguments.getClass())) { @SuppressWarnings("rawtypes") Iterable iterable = (Iterable) arguments; result.add(context.getObjectArrayConverter().convert(toArray(iterable), isVarargs, parameterTypes)); } else { result.add(context.getSingleArgConverter().convert(arguments, isVarargs, parameterTypes)); } } return result; }
/** * Converts the given data for the given test method and converter context. * * @param testMethod the original test method for which the data is converted; never {@code null} * @param data the data to be converted; never {@code null} * @param context the converter context to be used to do the data conversion; never {@code null} * @return a {@link Stream} of properly converted argument lists (= {@link List} of {@link Object}); never * {@code null} * @throws NullPointerException if and only if one of the given arguments is {@code null} */ protected Stream<List<Object>> convertData(Method testMethod, Object data, ConverterContext context) { checkNotNull(testMethod, "'testMethod' must not be null"); checkNotNull(data, "'data' must not be null"); checkNotNull(context, "'context' must not be null"); return dataConverter.convert(data, testMethod.isVarArgs(), testMethod.getParameterTypes(), context).stream() .map(c -> Arrays.asList(c)); } }
protected AbstractDataProviderInvocationContextProvider(Class<TEST_ANNOTATION> testAnnotationClass) { this(testAnnotationClass, new DataConverter()); }
/** * Converts the given data for the given test method and converter context. * * @param testMethod the original test method for which the data is converted; never {@code null} * @param data the data to be converted; never {@code null} * @param context the converter context to be used to do the data conversion; never {@code null} * @return a {@link Stream} of properly converted arguments; never {@code null} * @throws NullPointerException if and only if one of the given arguments is {@code null} */ protected Stream<? extends Arguments> convertData(Method testMethod, Object data, ConverterContext context) { checkNotNull(testMethod, "'testMethod' must not be null"); checkNotNull(data, "'data' must not be null"); checkNotNull(context, "'context' must not be null"); return dataConverter.convert(data, testMethod.isVarArgs(), testMethod.getParameterTypes(), context).stream() .map(objects -> { Class<?>[] parameterTypes = testMethod.getParameterTypes(); for (int idx = 0; idx < objects.length; idx++) { // TODO workaround for https://github.com/junit-team/junit5/issues/1092 Class<?> parameterType = parameterTypes[idx]; if (parameterType.isPrimitive()) { objects[idx] = convertToBoxedTypeAsWorkaroundForNotWorkingWideningAndUnboxingConversion( objects[idx], parameterType); } } return objects; }).map(Arguments::of); }
@Test public void testConvertShouldCallSingleArgConverterOnlyOnceForListOfObjectWithSingleElement() { // Given: List<Object> data = Arrays.<Object>asList(88); Class<?>[] parameterTypes = new Class<?>[] { Object.class }; // When: List<Object[]> result = underTest.convert(data, true, parameterTypes, context); // Then: assertThat(result).hasSize(1); verify(singleArgConverter).convert(data.get(0), true, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallObjectArrayConverterOnlyOnceForListOfListOfObjectWithOneElement() { // Given: @SuppressWarnings("unchecked") List<List<Character>> data = asList(asList('a')); Class<?>[] parameterTypes = new Class<?>[] { char.class }; // When: List<Object[]> result = underTest.convert(data, true, parameterTypes, context); // Then: assertThat(result).hasSize(1); verify(objectArrayConverter).convert(data.get(0).toArray(), true, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallStringConverterOnlyOnceForStringArrayWithOneElement() { // Given: String[] data = new String[] { "foo,true" }; Class<?>[] parameterTypes = new Class<?>[] { String.class, boolean.class }; // When: List<Object[]> result = underTest.convert(data, true, parameterTypes, context); // Then: assertThat(result).hasSize(1); verify(stringConverter).convert(data[0], true, parameterTypes, context, 0); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallSingleArgConverterOnlyOnceForObjectArrayWithSingleElement() { // Given: Object[] data = new Object[] { 88.99 }; Class<?>[] parameterTypes = new Class<?>[] { Object.class }; // When: List<Object[]> result = underTest.convert(data, true, parameterTypes, context); // Then: assertThat(result).hasSize(1); verify(singleArgConverter).convert(data[0], true, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallObjectArrayConverterOnlyOnceForObjectArrayArrayWithOneElement() { // Given: Object[][] data = new Object[][] { { 1 } }; Class<?>[] parameterTypes = new Class<?>[] { int.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(1); verify(objectArrayConverter).convert(data[0], false, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldReturnMultipleElementsForListOfListOfObjectWithMultipleElements() { // Given: @SuppressWarnings("unchecked") List<List<?>> data = asList(Arrays.<Object>asList('x', "foo"), asList('y', "bar"), asList('z', "baz")); Class<?>[] parameterTypes = new Class<?>[] { char.class, String.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(3); InOrder inOrder = inOrder(objectArrayConverter, singleArgConverter, stringConverter); inOrder.verify(objectArrayConverter).convert(data.get(0).toArray(), false, parameterTypes); inOrder.verify(objectArrayConverter).convert(data.get(1).toArray(), false, parameterTypes); inOrder.verify(objectArrayConverter).convert(data.get(2).toArray(), false, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallSingleArgConverterMultipleTimesForListOfObjectWithMultipleElements() { // Given: List<Object> data = Arrays.<Object>asList("12", 34L, 5.6); Class<?>[] parameterTypes = new Class<?>[] { Object.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(3); InOrder inOrder = inOrder(objectArrayConverter, singleArgConverter, stringConverter); inOrder.verify(singleArgConverter).convert(data.get(0), false, parameterTypes); inOrder.verify(singleArgConverter).convert(data.get(1), false, parameterTypes); inOrder.verify(singleArgConverter).convert(data.get(2), false, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertCallStringConverterMultipleTimesForStringArrayWithMultipleElements() { // Given: String[] data = new String[] { "1, 2, 3, 4.0, e", "6, 7, 8, 9.0, i" }; Class<?>[] parameterTypes = new Class<?>[] { byte.class, int.class, long.class, double.class, char.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(2); InOrder inOrder = inOrder(objectArrayConverter, singleArgConverter, stringConverter); inOrder.verify(stringConverter).convert(data[0], false, parameterTypes, context, 0); inOrder.verify(stringConverter).convert(data[1], false, parameterTypes, context, 1); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); } }
@Test public void testConvertShouldCallObjectArrayConverterMultipleTimesForObjectArrayArrayWithMultipleElements() { // Given: Object[][] data = new Object[][] { { "11", 22L, 3.3 }, { "44", 55L, 6.6 }, { "77", 88L, 9.9 } }; Class<?>[] parameterTypes = new Class<?>[] { String.class, long.class, double.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(3); InOrder inOrder = inOrder(objectArrayConverter, singleArgConverter, stringConverter); inOrder.verify(objectArrayConverter).convert(data[0], false, parameterTypes); inOrder.verify(objectArrayConverter).convert(data[1], false, parameterTypes); inOrder.verify(objectArrayConverter).convert(data[2], false, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldCallSingleArgConverterMultipleTimesForObjectArrayWithMultipleElements() { // Given: Object[] data = new Object[] { "12", 34L, 5.6 }; Class<?>[] parameterTypes = new Class<?>[] { Object.class }; // When: List<Object[]> result = underTest.convert(data, false, parameterTypes, context); // Then: assertThat(result).hasSize(3); InOrder inOrder = inOrder(objectArrayConverter, singleArgConverter, stringConverter); inOrder.verify(singleArgConverter).convert(data[0], false, parameterTypes); inOrder.verify(singleArgConverter).convert(data[1], false, parameterTypes); inOrder.verify(singleArgConverter).convert(data[2], false, parameterTypes); verifyNoMoreInteractions(objectArrayConverter, singleArgConverter, stringConverter); }
@Test public void testConvertShouldThrowIllegalArgumentExceptionIfParameterTypesIsEmpty() { // Given: Object data = null; Class<?>[] parameterTypes = new Class<?>[0]; expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("'parameterTypes' must not be empty"); // When: underTest.convert(data, false, parameterTypes, context); // Then: expect exception }
@Test public void testConvertShouldThrowNullPointerExceptionIfParameterTypesIsNull() { // Given: Object data = null; Class<?>[] parameterTypes = null; expectedException.expect(NullPointerException.class); expectedException.expectMessage("'parameterTypes' must not be null"); // When: underTest.convert(data, false, parameterTypes, context); // Then: expect exception }
@Test public void testConvertShouldThrowClassCastExceptionIfDataIsNotConvertable() { // Given: Object data = "not convertable"; Class<?>[] parameterTypes = new Class<?>[] { Integer.class }; expectedException.expect(ClassCastException.class); expectedException.expectMessage( "Cannot cast to either Object[][], Object[], String[], or Iterable because data was: " + data); // When: underTest.convert(data, false, parameterTypes, context); // Then: expect exception }
@Test public void testConvertShouldThrowClassCastExceptionIfDataIsNull() { // Given: Object data = null; Class<?>[] parameterTypes = new Class<?>[] { String.class }; expectedException.expect(ClassCastException.class); expectedException.expectMessage( "Cannot cast to either Object[][], Object[], String[], or Iterable because data was: null"); // When: underTest.convert(data, false, parameterTypes, context); // Then: expect exception }