String[] splitData = splitBy(data, dataProvider.splitBy());
@Before public void setup() { doReturn(DataProvider.COMMA).when(dataProvider).splitBy(); }
@Test(expected = IllegalArgumentException.class) public void testConvertShouldThrowExceptionIfVarargsAndNumberOfArgumentsIsTwoLessComparedToNumberOfParameterTypes() { // Given: String data = ""; Class<?>[] parameterTypes = new Class<?>[] { long.class, boolean.class, int[].class }; doReturn(",").when(dataProvider).splitBy(); // When: underTest.convert(data, true, parameterTypes, dataProvider, 3); // Then: expect exception }
@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 testConvertShouldNotTrimValuesIfSettingsTrimIsFalse() { // Given: String data = " foo| bar |baz "; Class<?>[] parameterTypes = new Class<?>[] { String.class, String.class, String.class }; doReturn("\\|").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 12); // Then: assertThat(result).containsExactly(" foo", " bar ", "baz "); }
@Test public void testConvertShouldCorrectlyParseAllPrimitiveTypesAsJavaString() { // Given: String data = "-5;2014l;-1.234567f;-901e-3"; Class<?>[] parameterTypes = new Class<?>[] { int.class, long.class, float.class, double.class }; doReturn(";").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 11); // Then: assertThat(result).containsExactly(-5, 2014l, -1.234567f, -0.901d); }
@Test public void testConvertShouldParseNullValuesAsStringIfSettingsConvertNullsIsFalse() { // Given: String data = "null#null"; Class<?>[] parameterTypes = new Class<?>[] { String.class, String.class }; doReturn("#").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 70); // Then: assertThat(result).containsExactly("null", "null"); }
@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 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 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 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 testConvertShouldCreateEmptyVarargsArrayForLastMissingVarargsArgument() { // Given: String data = "test"; Class<?>[] parameterTypes = new Class<?>[] { String.class, int[].class }; doReturn(",").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, true, parameterTypes, dataProvider, 91); // Then: assertThat(result).containsExactly("test", new int[0]); }
@Test public void testConvertShouldCreateVarargsArrayForOneOnlyVarargsArguments() { // Given: String data = "1.0"; Class<?>[] parameterTypes = new Class<?>[] { double[].class }; doReturn(",").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, true, parameterTypes, dataProvider, 92); // Then: assertThat(result).containsExactly(new double[] { 1.0 }); }
@Test public void testConvertShouldCorrectlyParseAllPrimitiveTypes() { // Given: String data = "true,1,c,2,3,4,5.5,6.6"; Class<?>[] parameterTypes = new Class<?>[] { boolean.class, byte.class, char.class, short.class, int.class, long.class, float.class, double.class }; doReturn(",").when(dataProvider).splitBy(); // When: Object[] result = underTest.convert(data, false, parameterTypes, dataProvider, 10); // Then: assertThat(result).containsExactly(true, (byte) 1, 'c', (short) 2, 3, 4L, 5.5f, 6.6d); }
@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 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 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 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 }); }