private Object convertValue(String data, Class<?> targetType, DataProvider dataProvider) { String str = (dataProvider.trimValues()) ? data.trim() : data; if (dataProvider.convertNulls() && NULL.equals(str)) { return null;
private Object convertValue(String data, Class<?> targetType, DataProvider dataProvider) { String str = (dataProvider.trimValues()) ? data.trim() : data; if (dataProvider.convertNulls() && NULL.equals(str)) { return null;
@Test public void testConvertShouldNotTrimNonBreakingSpaceEvenIfSettingsTrimIsTrue() { // Given: String data = "\u00A0test\u00A0"; Class<?>[] parameterTypes = new Class<?>[] { String.class }; doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 21); // Then: assertThat(result).containsExactly("\u00A0test\u00A0"); }
@Test public void testConvertShouldCorrectlyHandleLeadingEmptyString() { // Given: String data = "/true"; Class<?>[] parameterTypes = new Class<?>[] { String.class, boolean.class }; doReturn("/").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 30); // Then: assertThat(result).containsExactly("", true); }
@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); }
@Test public void testConvertShouldCorrectlyHandleTrailingEmptyString() { // Given: String data = "1 "; Class<?>[] parameterTypes = new Class<?>[] { int.class, String.class }; doReturn(" ").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 31); // Then: assertThat(result).containsExactly(1, ""); }
@Test public void testConvertShouldCorrectlyParseEnum() { // Given: String data = " VAL1, VAL2 "; Class<?>[] parameterTypes = new Class<?>[] { TestEnum.class, TestEnum.class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 50); // Then: assertThat(result).containsExactly(TestEnum.VAL1, TestEnum.VAL2); }
@Test public void testConvertShouldCreateVarargsArrayForMultipleLastVarargsArguments() { // Given: String data = "foobar, 1, 2, 3"; Class<?>[] parameterTypes = new Class<?>[] { String.class, long[].class }; doReturn(",").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, true, parameterTypes, dataProvider, 95); // Then: assertThat(result).containsExactly("foobar", new long[] { 1, 2, 3 }); }
@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); }
@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 public void testConvertShouldTrimAndParseAllPrimitiveTypesIfSettingsTrimIsTrue() { // Given: String data = " false ; 11 ; z ; 22 ; 33 ;44 ; 55.55 ; 66.66 "; Class<?>[] parameterTypes = new Class<?>[] { boolean.class, byte.class, char.class, short.class, int.class, long.class, float.class, double.class }; doReturn(";").when(dataProvider).splitBy(); doReturn(true).when(dataProvider).trimValues(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 13); // Then: assertThat(result).containsExactly(false, (byte) 11, 'z', (short) 22, 33, 44L, 55.55f, 66.66d); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }