@DataProvider public static Object[][] emptyAfterTrim() { return new Object[][] { {""}, {" "}, {" "} }; }
private Object convertValue(String data, Class<?> targetType, DataProvider dataProvider) { String str = (dataProvider.trimValues()) ? data.trim() : data; if (dataProvider.convertNulls() && NULL.equals(str)) { return null; @SuppressWarnings({ "unchecked", "rawtypes" }) Class<Enum> enumType = (Class<Enum>) targetType; return convertToEnumValue(str, enumType, dataProvider.ignoreEnumCase());
private List<FrameworkMethod> explodeTestMethod(FrameworkMethod testMethod, Object data, DataProvider dataProvider) { Method method = testMethod.getMethod(); List<Object[]> converted = dataConverter.convert(data, method.isVarArgs(), method.getParameterTypes(), dataProvider); if (converted.isEmpty()) { throw new IllegalArgumentException( "Could not create test methods using probably 'null' or 'empty' dataprovider"); } int idx = 0; List<FrameworkMethod> result = new ArrayList<FrameworkMethod>(); for (Object[] parameters : converted) { result.add(new DataProviderFrameworkMethod(method, idx++, parameters, dataProvider.format())); } return result; } }
/** * Converts the given {@code data} to its corresponding arguments using the given {@code parameterTypes} and other * provided information. * * @param data regex-separated {@link String} of parameters for test method * @param isVarargs determines whether test method has a varargs parameter * @param parameterTypes target types of parameters to which corresponding values in regex-separated {@code data} * should be converted * @param dataProvider containing settings which should be used to convert given {@code data} * @param rowIdx index of current {@code data} (row) for better error messages * @return split, trimmed and converted {@code Object[]} of supplied regex-separated {@code data} * @throws IllegalArgumentException iif count of split data and parameter types does not match or argument cannot be * converted to required type */ public Object[] convert(String data, boolean isVarargs, Class<?>[] parameterTypes, DataProvider dataProvider, int rowIdx) { ConverterContext context = new ConverterContext(dataProvider.splitBy(), dataProvider.convertNulls(), dataProvider.trimValues(), dataProvider.ignoreEnumCase()); return super.convert(data, isVarargs, parameterTypes, context, rowIdx); }
@Test public void testConvertShouldCorrectlyParseClass() { // Given: String data = " java.lang.Thread, com.tngtech.java.junit.dataprovider.DataProviderRunner "; Class<?>[] parameterTypes = new Class<?>[] { Class.class, Class.class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 50); // Then: assertThat(result).containsExactly(Thread.class, DataProviderRunner.class); }
String[] splitData = splitBy(data, dataProvider.splitBy());
@Test public void testConvertShouldParseNullValuesAsNullObjectIfSettingsConvertNullsIsTrue() { // Given: String data = "null,null,foo"; Class<?>[] parameterTypes = new Class<?>[] { String.class, String.class, String.class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).convertNulls(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 71); // Then: assertThat(result).containsExactly(null, null, "foo"); }
@Test public void testConvertShouldCorrectlyParseEnumIgnoringCase() { // Given: String data = "Val1,val2"; Class<?>[] parameterTypes = new Class<?>[] { TestEnum.class, TestEnum.class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).ignoreEnumCase(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 50); // Then: assertThat(result).containsExactly(TestEnum.VAL1, TestEnum.VAL2); }
@Test public void testExplodeTestMethodsUseDataProviderShouldReturnMultipleDataProviderFrameworkMethodIfDataConverterReturnsMultipleRows() throws Throwable { // Given: List<Object[]> dataConverterResult = listOfArrays(new Object[] { 11, "22", 33L }, new Object[] { 44, "55", 66L }, new Object[] { 77, "88", 99L }); doReturn(dataConverterResult).when(dataConverter).convert(any(), any(Boolean.class), any(Class[].class), any(DataProvider.class)); doReturn(dataProvider).when(dataProviderMethod).getAnnotation(DataProvider.class); doReturn("%c").when(dataProvider).format(); doReturn(false).when(dataProvider).cache(); // When: List<FrameworkMethod> result = underTest.explodeTestMethod(testMethod, dataProviderMethod); // Then: assertThat(TestGenerator.dataProviderDataCache).isEmpty(); assertDataProviderFrameworkMethods(result, dataConverterResult, "%c"); verify(dataProviderMethod).invokeExplosively(null); }
private List<FrameworkMethod> explodeTestMethod(FrameworkMethod testMethod, Object data, DataProvider dataProvider) { Method method = testMethod.getMethod(); List<Object[]> converted = dataConverter.convert(data, method.isVarArgs(), method.getParameterTypes(), dataProvider); if (converted.isEmpty()) { throw new IllegalArgumentException("Could not create test methods using probably 'null' or 'empty' dataprovider"); } int idx = 0; List<FrameworkMethod> result = new ArrayList<FrameworkMethod>(); for (Object[] parameters : converted) { result.add(new DataProviderFrameworkMethod(method, idx++, parameters, dataProvider.format(), dataProvider.formatter())); } return result; } }
/** * Converts the given {@code data} to its corresponding arguments using the given {@code parameterTypes} and other * provided information. * * @param data regex-separated {@link String} of parameters for test method * @param isVarargs determines whether test method has a varargs parameter * @param parameterTypes target types of parameters to which corresponding values in regex-separated {@code data} * should be converted * @param dataProvider containing settings which should be used to convert given {@code data} * @param rowIdx index of current {@code data} (row) for better error messages * @return split, trimmed and converted {@code Object[]} of supplied regex-separated {@code data} * @throws IllegalArgumentException iif count of split data and parameter types does not match or argument cannot be * converted to required type */ public Object[] convert(String data, boolean isVarargs, Class<?>[] parameterTypes, DataProvider dataProvider, int rowIdx) { ConverterContext context = new ConverterContext(dataProvider.splitBy(), dataProvider.convertNulls(), dataProvider.trimValues(), dataProvider.ignoreEnumCase()); return super.convert(data, isVarargs, parameterTypes, context, rowIdx); }
@Test public void testConvertShouldCreateVarargsArrayForMultipleOnlyVarargsArguments() { // Given: String data = "1, 2, 3"; Class<?>[] parameterTypes = new Class<?>[] { long[].class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, true, parameterTypes, dataProvider, 94); // Then: assertThat(result).containsExactly(new long[] { 1, 2, 3 }); }
@Test(expected = IllegalArgumentException.class) public void testConvertShouldThrowExceptionIfNumberOfArgumentsIsNotEqualToNumberOfParameterTypes() { // Given: String data = ""; Class<?>[] parameterTypes = new Class<?>[] { String.class, int.class }; doReturn(",").when(dataProvider).splitBy(); // When: underTest.convert(data, false, parameterTypes, dataProvider, 2); // Then: expect exception }
@Test public void testConvertShouldCreateVarargsArrayForOneLastVarargsArguments() { // Given: String data = "a,2,1.0,null"; Class<?>[] parameterTypes = new Class<?>[] { char.class, byte.class, Double[].class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).convertNulls(); // When: Object[] result = underTest.convert(data, true, parameterTypes, dataProvider, 93); // Then: assertThat(result).containsExactly('a', (byte) 2, new Double[] { 1.0, null }); }
@Test public void testExplodeTestMethodsUseDataProviderShouldReturnFrameworkMethodInjectedToUseDataProviderMethodIfExists() throws Throwable { // Given: final Method method = getMethod("dataProviderMethod"); doReturn(method).when(dataProviderMethod).getMethod(); List<Object[]> dataConverterResult = listOfArrays(new Object[] { null }); doReturn(dataConverterResult).when(dataConverter).convert(any(), anyBoolean(), any(Class[].class), any(DataProvider.class)); doReturn(dataProvider).when(dataProviderMethod).getAnnotation(DataProvider.class); doReturn(DataProvider.DEFAULT_FORMAT).when(dataProvider).format(); doReturn(true).when(dataProvider).cache(); // When: List<FrameworkMethod> result = underTest.explodeTestMethod(testMethod, dataProviderMethod); // Then: assertThat(TestGenerator.dataProviderDataCache).hasSize(1).containsKey(dataProviderMethod); assertThat(result).hasSize(1); verify(dataProviderMethod).invokeExplosively(null, testMethod); }
private List<FrameworkMethod> explodeTestMethod(FrameworkMethod testMethod, Object data, DataProvider dataProvider) { Method method = testMethod.getMethod(); List<Object[]> converted = dataConverter.convert(data, method.isVarArgs(), method.getParameterTypes(), dataProvider); if (converted.isEmpty()) { throw new IllegalArgumentException("Could not create test methods using probably 'null' or 'empty' dataprovider"); } int idx = 0; List<FrameworkMethod> result = new ArrayList<FrameworkMethod>(); for (Object[] parameters : converted) { result.add(new DataProviderFrameworkMethod(method, idx++, parameters, dataProvider.format(), dataProvider.formatter())); } return result; } }
@DataProvider public static Object[][] datasetIdSupportedLengths() { return new Object[][] { {ServerId.NOT_UUID_DATASET_ID_LENGTH}, {UUID_DATASET_ID_LENGTH}, }; } }
/** * Converts the given {@link Object} to a {@link List} of {@link Object}{@code []} with {@link Class}es correspond * to given {@code parameterTypes}. * <p> * For compatible types, see {@link #canConvert(Type)}. * * @param data to be converted * @param isVarargs determines whether test method has a varargs parameter * @param parameterTypes required types for {@code data} * @param dataProvider containing settings which should be used to convert given {@code data} * @return converted data as {@link List}{@code <}{@link Object}{@code []>} with the required {@code parameterTypes} * @throws NullPointerException iif given {@code parameterTypes} or {@code settings} are {@code null} * @throws IllegalArgumentException iif given {@code parameterTypes} is empty * @throws ClassCastException iif {@code data} is not a compatible type */ public List<Object[]> convert(Object data, boolean isVarargs, Class<?>[] parameterTypes, DataProvider dataProvider) { checkNotNull(dataProvider, "dataProvider must not be null"); ConverterContext context = new ConverterContext(objectArrayConverter, singleArgConverter, stringConverter, dataProvider.splitBy(), dataProvider.convertNulls(), dataProvider.trimValues(), dataProvider.ignoreEnumCase()); return super.convert(data, isVarargs, parameterTypes, context); }
@Test public void testConvertShouldTrimNonSpaceWhitespaceCharsIfSettingsTrimIsTrue() { // Given: String data = "\n-1f\n,\r-2\r,\t3.0d\t"; Class<?>[] parameterTypes = new Class<?>[] { float.class, int.class, double.class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 20); // Then: assertThat(result).containsExactly(-1f, -2, 3d); }
private Object convertValue(String data, Class<?> targetType, DataProvider dataProvider) { String str = (dataProvider.trimValues()) ? data.trim() : data; if (dataProvider.convertNulls() && NULL.equals(str)) { return null; @SuppressWarnings({ "unchecked", "rawtypes" }) Class<Enum> enumType = (Class<Enum>) targetType; return convertToEnumValue(str, enumType, dataProvider.ignoreEnumCase());