diff options
Diffstat (limited to 'src/test/java')
40 files changed, 2311 insertions, 0 deletions
diff --git a/src/test/java/junitparams/AssumptionsTest.java b/src/test/java/junitparams/AssumptionsTest.java new file mode 100644 index 0000000..19419cb --- /dev/null +++ b/src/test/java/junitparams/AssumptionsTest.java @@ -0,0 +1,19 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.*; +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assume.*; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class AssumptionsTest { + + @Test + @Parameters({ "true", "false" }) + public void assumeOnceWorksAndOnceIgnores(boolean value) { + assumeThat(value, is(true)); + assertThat(value).isTrue(); + } +} diff --git a/src/test/java/junitparams/BeforeAfterClassTest.java b/src/test/java/junitparams/BeforeAfterClassTest.java new file mode 100644 index 0000000..8ccfcc5 --- /dev/null +++ b/src/test/java/junitparams/BeforeAfterClassTest.java @@ -0,0 +1,28 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class BeforeAfterClassTest { + + private static boolean val = false; + + @BeforeClass + public static void before() { + val = true; + } + + @AfterClass + public static void after() { + val = false; + } + + @Test + @Parameters({ " " }) + public void test(String param) { + assertThat(val).isTrue(); + } +} diff --git a/src/test/java/junitparams/CastingParamsTest.java b/src/test/java/junitparams/CastingParamsTest.java new file mode 100644 index 0000000..83414a2 --- /dev/null +++ b/src/test/java/junitparams/CastingParamsTest.java @@ -0,0 +1,62 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.*; + +import org.junit.*; +import org.junit.runner.*; + +import junitparams.usage.person_example.*; + +@RunWith(JUnitParamsRunner.class) +public class CastingParamsTest { + + @Test + @Parameters + public void wrapWithTypeBySingleArgConstructor(PersonTest.Person person) { + assertThat(person.getAge()).isGreaterThan(0); + } + List<Integer> parametersForWrapWithTypeBySingleArgConstructor() { + return Arrays.asList(1, 2); + } + + @Test + @Parameters + public void wrapWithTypeByMultiArgConstructor(PersonTest.Person person) { + assertThat(person.getAge()).isGreaterThan(0); + } + Object parametersForWrapWithTypeByMultiArgConstructor() { + return new Object[]{new Object[]{"first", 1}, new Object[]{"second", 2}}; + } + + @Test + @Parameters + public void cartoonCharacters(PersonTest.Person character) { + assertThat(character.getName()).isIn("Tarzan", "Jane"); + assertThat(character.getAge()).isIn(0, 20); + } + + private List<?> parametersForCartoonCharacters() { + return Arrays.asList( + new Object[]{"Tarzan", 0}, + new Object[]{"Jane", 20} + ); + } + + @Test + @Parameters(method = "strings") + public void stringArrayFromMethod(String... values) { + assertThat(values).containsOnlyOnce("1", "2"); + } + private Object strings() { + return new Object[]{new Object[]{"1", "2"}, new Object[]{"2", "1"}}; + } + + @Test + @Parameters({"a,b", "b,a"}) + public void stringArrayFromAnnotation(String... values) { + assertThat(values).containsOnlyOnce("a","b"); + } + +} diff --git a/src/test/java/junitparams/ClassesAsParamsTest.java b/src/test/java/junitparams/ClassesAsParamsTest.java new file mode 100644 index 0000000..7d199c2 --- /dev/null +++ b/src/test/java/junitparams/ClassesAsParamsTest.java @@ -0,0 +1,22 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class ClassesAsParamsTest { + + @Test + @Parameters({"java.lang.Object", "java.lang.String"}) + public void passClassAsString(Class<?> clazz) { + assertThat(clazz).isIn(java.lang.Object.class, java.lang.String.class); + } + + @Test(expected = IllegalArgumentException.class) + @Parameters("no.package.NoSuchClass") + public void illegalArgumentExceptionWhenClassNotFound(Class<?> clazz) { + fail("Should fail on test invocation"); + } +} diff --git a/src/test/java/junitparams/EnumsAsParamsTest.java b/src/test/java/junitparams/EnumsAsParamsTest.java new file mode 100644 index 0000000..621cfed --- /dev/null +++ b/src/test/java/junitparams/EnumsAsParamsTest.java @@ -0,0 +1,28 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.*; +import org.junit.runner.*; + +import junitparams.usage.person_example.*; + +@RunWith(JUnitParamsRunner.class) +public class EnumsAsParamsTest { + + @Test + @Parameters({"SOME_VALUE", "OTHER_VALUE"}) + public void passEnumAsString(PersonType person) { + assertThat(person).isIn(PersonType.SOME_VALUE, PersonType.OTHER_VALUE); + } + + @Test + @Parameters + public void passEnumFromMethod(PersonType person) { + assertThat(person).isIn(parametersForPassEnumFromMethod()); + } + + private PersonType[] parametersForPassEnumFromMethod() { + return new PersonType[] {PersonType.SOME_VALUE, PersonType.OTHER_VALUE}; + } +} diff --git a/src/test/java/junitparams/FileParamsTest.java b/src/test/java/junitparams/FileParamsTest.java new file mode 100644 index 0000000..b581400 --- /dev/null +++ b/src/test/java/junitparams/FileParamsTest.java @@ -0,0 +1,56 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.mappers.CsvWithHeaderMapper; +import junitparams.usage.person_example.PersonMapper; +import junitparams.usage.person_example.PersonTest.Person; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class FileParamsTest { + + @Test + @FileParameters("src/test/resources/test.csv") + public void loadParamsFromFileWithIdentityMapper(int age, String name) { + assertThat(age).isGreaterThan(0); + } + + @Test + @FileParameters(value = "src/test/resources/test.csv", mapper = PersonMapper.class) + public void loadParamsFromFileWithCustomMapper(Person person) { + assertThat(person.getAge()).isGreaterThan(0); + } + + @Test + @FileParameters("classpath:test.csv") + public void loadParamsFromFileAtClasspath(int age, String name) { + assertThat(age).isGreaterThan(0); + } + + @Test + @FileParameters("file:src/test/resources/test.csv") + public void loadParamsFromFileAtFilesystem(int age, String name) { + assertThat(age).isGreaterThan(0); + } + + @Test + @FileParameters(value = "classpath:with_header.csv", mapper = CsvWithHeaderMapper.class) + public void csvWithHeader(int id, String name) { + assertThat(id).isGreaterThan(0); + } + + @Test + @FileParameters(value = "classpath:with_special_chars.csv", encoding = "UTF-8") + public void loadParamWithCorrectEncoding(String value) { + assertThat(value).isEqualTo("åäöÅÄÖ"); + } + + @Test + @FileParameters(value = "classpath:with_special_chars.csv", encoding = "ISO-8859-1") + public void loadParamWithWrongEncoding(String value) { + assertThat(value).isNotEqualTo("åäöÅÄÖ"); + } +} diff --git a/src/test/java/junitparams/FilterableTest.java b/src/test/java/junitparams/FilterableTest.java new file mode 100644 index 0000000..05b2b4c --- /dev/null +++ b/src/test/java/junitparams/FilterableTest.java @@ -0,0 +1,82 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.JUnitCore; +import org.junit.runner.Request; +import org.junit.runner.Result; +import org.junit.runner.manipulation.Filter; + +import static org.assertj.core.api.Assertions.*; + +public class FilterableTest { + + @Test + public void shouldRunAllTests() throws Exception { + Request request = Request.aClass(SampleTestCase.class); + + Result result = new JUnitCore().run(request); + + assertThat(result.getRunCount()).isEqualTo(3); + } + + @Test + public void shouldRunSingleTestWithoutParameters() throws Exception { + Request request = requestSingleMethodRun(SampleTestCase.class, "firstTestMethod"); + + Result result = new JUnitCore().run(request); + + assertThat(result.getRunCount()).isEqualTo(1); + } + + @Test + public void shouldRunParametrisedTest() throws Exception { + Request request = requestSingleMethodRun(SampleTestCase.class, "secondTestMethod"); + + Result result = new JUnitCore().run(request); + + assertThat(result.getRunCount()).isEqualTo(2); + } + + @Test + public void shouldReturnOneDescriptionForSimpleTestCase() throws Exception { + Request request = requestSingleMethodRun(SampleTestCase.class, "firstTestMethod"); + + Description description = request.getRunner().getDescription(); + + assertThat(description.getChildren()).hasSize(1); + assertThat(description.getChildren().get(0).getChildren()).hasSize(0); + } + + @Test + public void shouldReturnParametrizedDescriptionsForParametrizedTestCase() throws Exception { + Request request = requestSingleMethodRun(SampleTestCase.class, "secondTestMethod"); + + Description description = request.getRunner().getDescription(); + + assertThat(description.getChildren()).hasSize(1); + assertThat(description.getChildren().get(0).getChildren()).hasSize(2); + } + + private Request requestSingleMethodRun(Class<SampleTestCase> clazz, String methodName) { + return Request.aClass(clazz).filterWith(new SingleMethodFilter(methodName)); + } + + private static class SingleMethodFilter extends Filter { + private final String methodName; + + public SingleMethodFilter(String methodName) { + this.methodName = methodName; + } + + @Override + public boolean shouldRun(Description description) { + return description.getDisplayName().contains(methodName); + } + + @Override + public String describe() { + return methodName; + } + } +} diff --git a/src/test/java/junitparams/IgnoringTest.java b/src/test/java/junitparams/IgnoringTest.java new file mode 100644 index 0000000..ef667bd --- /dev/null +++ b/src/test/java/junitparams/IgnoringTest.java @@ -0,0 +1,46 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class IgnoringTest { + + @Test + @Ignore + public void ignoreMeNoParams() { + fail("Should be ignored"); + } + + @Test + @Ignore + @Parameters("") + public void ignoreMeWithParams() { + fail("Should be ignored"); + } + + @Test + public void dontIgnoreMeNoParams() { + } + + @Test + @Parameters("") + public void dontIgnoreMeWithParams(String a) { + assertThat(a).isEqualTo(""); + } + + @Test + @Ignore + @Parameters(method = "someMethod") + public void shouldNotTryToInvokeMethodWhenTestIgnored(Object a) { + fail("Should be ignored"); + } + + private Object[] someMethod() { + fail("Should not be called"); + return null; + } +} diff --git a/src/test/java/junitparams/InstantiatingTestClassOnceTest.java b/src/test/java/junitparams/InstantiatingTestClassOnceTest.java new file mode 100644 index 0000000..9449bdf --- /dev/null +++ b/src/test/java/junitparams/InstantiatingTestClassOnceTest.java @@ -0,0 +1,23 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public class InstantiatingTestClassOnceTest { + + private static final int NUMBER_OF_TEST_METHODS_IN_THIS_CLASS = 1; + private static int instantiationsCount = 0; + + @Test + public void shouldBeInstantiatedOncePerTestMethod() { + assertThat(instantiationsCount).isEqualTo(NUMBER_OF_TEST_METHODS_IN_THIS_CLASS); + } + + public InstantiatingTestClassOnceTest() { + instantiationsCount++; + } + +}
\ No newline at end of file diff --git a/src/test/java/junitparams/IterableMethodTest.java b/src/test/java/junitparams/IterableMethodTest.java new file mode 100644 index 0000000..7d2e357 --- /dev/null +++ b/src/test/java/junitparams/IterableMethodTest.java @@ -0,0 +1,36 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public class IterableMethodTest { + + @Test + @Parameters + public void shouldHandleIterables(String a) { + assertThat(a).isEqualTo("a"); + } + + public List<Object[]> parametersForShouldHandleIterables() { + ArrayList<Object[]> params = new ArrayList<Object[]>(); + params.add(new Object[]{"a"}); + return params; + } + + @Test + @Parameters + public void shouldHandleSimplifiedIterables(String a) { + assertThat(a).isEqualTo("a"); + } + + public List<String> parametersForShouldHandleSimplifiedIterables() { + return Arrays.asList("a"); + } +}
\ No newline at end of file diff --git a/src/test/java/junitparams/IteratorMethodTest.java b/src/test/java/junitparams/IteratorMethodTest.java new file mode 100644 index 0000000..219643f --- /dev/null +++ b/src/test/java/junitparams/IteratorMethodTest.java @@ -0,0 +1,44 @@ +package junitparams; + +import static org.junit.Assert.assertEquals; + +import java.util.*; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class IteratorMethodTest { + private static boolean firstCalled = false; + + @Test + @Parameters + public void shouldHandleIteratorsWithObject(String a) { + assertEquals(1, a.length()); + if(a.equals("a")) firstCalled = true; + else assertEquals(firstCalled, true); + } + + public Iterator<Object> parametersForShouldHandleIteratorsWithObject() { + ArrayList<Object> params = new ArrayList<Object>(); + params.add("a"); + params.add("b"); + return params.iterator(); + } + + @Test + @Parameters + public void shouldHandleIteratorsWithObjectArray(String a) { + assertEquals(1, a.length()); + if(a.equals("a")) firstCalled = true; + else assertEquals(firstCalled, true); + } + + public Iterator<Object[]> parametersForShouldHandleIteratorsWithObjectArray() { + ArrayList<Object[]> params = new ArrayList<Object[]>(); + params.add(new Object[]{"a"}); + params.add(new Object[]{"b"}); + return params.iterator(); + } + +}
\ No newline at end of file diff --git a/src/test/java/junitparams/MethodAnnotationArgumentTest.java b/src/test/java/junitparams/MethodAnnotationArgumentTest.java new file mode 100644 index 0000000..94999be --- /dev/null +++ b/src/test/java/junitparams/MethodAnnotationArgumentTest.java @@ -0,0 +1,83 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Arrays; +import java.util.List; + +import junitparams.usage.person_example.PersonTest; +import junitparams.usage.person_example.PersonTest.Person; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@SuppressWarnings("unused") +@RunWith(JUnitParamsRunner.class) +public class MethodAnnotationArgumentTest { + + @Test + @Parameters(method = "return1") + public void testSingleMethodName(int number) { + assertThat(number).isEqualTo(1); + } + + private Integer[] return1() { + return new Integer[] { 1 }; + } + + @Test + @Parameters(method = "return1,return2") + public void testMultipleMethodNames(int number) { + assertThat(number) + .isLessThanOrEqualTo(2) + .isGreaterThanOrEqualTo(1); + } + + @Test + @Parameters(method = "return1, return2") + public void testMultipleMethodNamesWithWhitespaces(int number) { + assertThat(number) + .isLessThanOrEqualTo(2) + .isGreaterThanOrEqualTo(1); + } + + private Integer[] return2() { + return new Integer[] { 2 }; + } + + @Test + @Parameters(source = PersonTest.class, method = "adultValues") + public void testSingleMethodFromDifferentClass(int age, boolean valid) { + assertThat(new Person(age).isAdult()).isEqualTo(valid); + } + + @Test + @Parameters(method = "stringParamsWithNull") + public void shouldPassStringParamsWithNullFromMethod(String parameter) { + // given + List<String> acceptedParams = Arrays.asList("1", "2", "3", null); + + // then + assertThat(acceptedParams).contains(parameter); + } + + Object[] stringParamsWithNull() { + return genericArray("1", "2", "3", null); + } + + @Test + @Parameters(method = "multiStringParams") + public void shouldPassMultiStringParams(String first, String second) { + assertThat(first).isEqualTo(second); + } + + Object[] multiStringParams() { + return genericArray( + genericArray("test", "test"), + genericArray("ble", "ble")); + } + + private static <T> T[] genericArray(T... elements) { + return elements; + } +} diff --git a/src/test/java/junitparams/MultipleParameterProvidersTest.java b/src/test/java/junitparams/MultipleParameterProvidersTest.java new file mode 100644 index 0000000..70fe386 --- /dev/null +++ b/src/test/java/junitparams/MultipleParameterProvidersTest.java @@ -0,0 +1,41 @@ +package junitparams; + +import junitparams.internal.parameters.ParametersReader; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.RunWith; +import org.junit.runner.notification.Failure; + +import static org.junit.Assert.assertEquals; + +import static java.lang.String.format; + +public class MultipleParameterProvidersTest { + + @RunWith(JUnitParamsRunner.class) + private class CantInitializeWithValueAndMethodProvider { + private Object[] extraProvider() { + return new Object[][]{ + {"test", "test"}, + }; + } + + @Parameters(value = {"test, test"}, method = "extraProvider") + @Test + public void testWithValueAndMethodProviders(String input, String output) { + assertEquals(input, output); + } + } + + @Test + public void testWithValueAndMethodProvidersThrowsIllegalStateException() { + Result testResult = JUnitCore.runClasses(CantInitializeWithValueAndMethodProvider.class); + assertEquals(1, testResult.getFailureCount()); + + Failure testFailure = testResult.getFailures().iterator().next(); + assertEquals(IllegalStateException.class, testFailure.getException().getClass()); + assertEquals(format(ParametersReader.ILLEGAL_STATE_EXCEPTION_MESSAGE, "testWithValueAndMethodProviders"), + testFailure.getMessage()); + } +} diff --git a/src/test/java/junitparams/NullValuesTest.java b/src/test/java/junitparams/NullValuesTest.java new file mode 100644 index 0000000..25d68d1 --- /dev/null +++ b/src/test/java/junitparams/NullValuesTest.java @@ -0,0 +1,43 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class NullValuesTest { + + private Object[] expectedSingleParams = new Object[]{null, "string", Long.valueOf(1)}; + + private static int expectedSingleParamsIndex; + + private Object[] expectedMultipleParams = multipleParams(); + private static int expectedMultipleParamsIndex; + + @Test + @Parameters(method = "singleParams") + public void passesForSingleParametersListWithTheWorkaround(Object param) { + assertThat(param).isEqualTo(expectedSingleParams[expectedSingleParamsIndex]); + expectedSingleParamsIndex++; + } + + public Object[] singleParams() { + return new Object[]{new Object[]{null}, "string", Long.valueOf(1)}; + } + + @Test + @Parameters(method = "multipleParams") + public void passesForMultipleParametersOutOfBox(Object param1, Object param2, Object param3) { + assertThat(param1).isEqualTo(((Object[]) expectedMultipleParams[expectedMultipleParamsIndex])[0]); + assertThat(param2).isEqualTo(((Object[]) expectedMultipleParams[expectedMultipleParamsIndex])[1]); + assertThat(param3).isEqualTo(((Object[]) expectedMultipleParams[expectedMultipleParamsIndex])[2]); + expectedMultipleParamsIndex++; + } + + public Object[] multipleParams() { + return new Object[]{new Object[]{null, "string", null}, new Object[]{"string", Long + .valueOf(1), null}, new Object[]{null, null, null}}; + } + +} diff --git a/src/test/java/junitparams/ObjectStringificationTest.java b/src/test/java/junitparams/ObjectStringificationTest.java new file mode 100644 index 0000000..79507d0 --- /dev/null +++ b/src/test/java/junitparams/ObjectStringificationTest.java @@ -0,0 +1,94 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.internal.Utils; + +import static junitparams.JUnitParamsRunner.*; +import static junitparams.internal.Utils.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; + + +@RunWith(JUnitParamsRunner.class) +public class ObjectStringificationTest { + + @Test + public void stringifyString() throws Exception { + assertThat(stringify("exampleName", 0)).isEqualTo("[0] exampleName"); + } + + @Test + public void stringifyClassWithToStringAndOneParam() throws Exception { + ClassWithToString obj = new ClassWithToString("exampleName"); + + assertThat(stringify(obj, 0)).isEqualTo("[0] exampleName"); + } + + @Test + public void stringifyClassWithToStringAndManyParams() throws Exception { + ClassWithToString obj1 = new ClassWithToString("one"); + ClassWithToString obj2 = new ClassWithToString("two"); + + assertThat(stringify(new Object[]{obj1, obj2}, 0)).isEqualTo("[0] one, two"); + } + + @Test + public void stringifyClassWithToStringInSuperclass() throws Exception { + ClassWithToString obj = new ClassWithToString("exampleName"); + + assertThat(Utils.stringify(obj, 0)).isEqualTo("[0] exampleName"); + } + + private class ClassWithToString { + private String description; + + public ClassWithToString(String description) { + this.description = description; + } + + @Override + public String toString() { + return description; + } + } + + @Test + public void stringifyArray() { + Double[] nullArray = null; + int[] primitiveArray = {1, 2, 3}; + String[] array = {"one", "two", null}; + Object[] mixed = $( + $(nullArray, "stringOne", primitiveArray, "stringTwo", array) + ); + + assertThat(Utils.stringify(mixed)).isEqualTo("null, stringOne, [1, 2, 3], stringTwo, [one, two, null]"); + } + + @Test + @Parameters + public void shouldCreateParameterObjectsOnce(Object object) { + assertThat(object).isInstanceOf(A.class); + } + + public Object[] parametersForShouldCreateParameterObjectsOnce() { + return new Object[]{new A()}; + } + + static class A { + static int instances = 0; + String test = "test"; + + A() { + if (++instances > 1) { + fail(); + } + } + + @Override + public String toString() { + return "[0] exampleName" + super.toString(); + } + } +} diff --git a/src/test/java/junitparams/OverloadedTestMethodNameTest.java b/src/test/java/junitparams/OverloadedTestMethodNameTest.java new file mode 100644 index 0000000..e3a2380 --- /dev/null +++ b/src/test/java/junitparams/OverloadedTestMethodNameTest.java @@ -0,0 +1,27 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.*; +import org.junit.runner.*; + +@RunWith(JUnitParamsRunner.class) +public class OverloadedTestMethodNameTest { + + @Test + public void aTest() { + } + + @Test + @Parameters({ "1", "2" }) + public void aTest(int number) { + assertThat(number).isIn(1, 2); + } + + @Test + @Parameters({ "1,2" }) + public void aTest(int number1, int number2) { + assertThat(number1).isEqualTo(1); + assertThat(number2).isEqualTo(2); + } +} diff --git a/src/test/java/junitparams/ParametersConvertedWithPropertyEditorTest.java b/src/test/java/junitparams/ParametersConvertedWithPropertyEditorTest.java new file mode 100644 index 0000000..9d71418 --- /dev/null +++ b/src/test/java/junitparams/ParametersConvertedWithPropertyEditorTest.java @@ -0,0 +1,44 @@ +package junitparams; + +import java.beans.PropertyEditorManager; +import java.beans.PropertyEditorSupport; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class ParametersConvertedWithPropertyEditorTest { + + @BeforeClass + public static void registerEditors() { + PropertyEditorManager.registerEditor(StringWrapper.class, StringWrapperPropertyEditor.class); + } + + @Test + @Parameters({"wrapped , wrapped"}) + public void convertsToCustomType(StringWrapper wrapper, String text) { + assertThat(wrapper.getText()).isEqualTo(text); + } + + public static class StringWrapperPropertyEditor extends PropertyEditorSupport { + @Override + public void setAsText(String text) throws IllegalArgumentException { + setValue(new StringWrapper(text)); + } + } + + private static class StringWrapper { + private String text; + + StringWrapper(String text) { + this.text = text; + } + + String getText() { + return text; + } + } +} diff --git a/src/test/java/junitparams/ParametersForEnumTest.java b/src/test/java/junitparams/ParametersForEnumTest.java new file mode 100644 index 0000000..30645e7 --- /dev/null +++ b/src/test/java/junitparams/ParametersForEnumTest.java @@ -0,0 +1,35 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.*; + +import java.util.HashSet; +import java.util.Set; + +import org.junit.AfterClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public class ParametersForEnumTest { + + private static Set<Fruit> testedFruits = new HashSet<Fruit>(); + + @AfterClass + public static void checkAllFruitsTested() { + assertThat(testedFruits).contains(Fruit.class.getEnumConstants()); + } + + @Test + @Parameters(source = Fruit.class) + public void testAFruit(Fruit fruit) throws Exception { + testedFruits.add(fruit); + } + + public enum Fruit { + APPLE, + BANANA, + PEAR, + PLUM + } + +} diff --git a/src/test/java/junitparams/ParametersReaderForMethodTest.java b/src/test/java/junitparams/ParametersReaderForMethodTest.java new file mode 100644 index 0000000..4e4d07f --- /dev/null +++ b/src/test/java/junitparams/ParametersReaderForMethodTest.java @@ -0,0 +1,65 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; + +import org.junit.*; +import org.junit.runner.*; + +@SuppressWarnings("unused") +@RunWith(JUnitParamsRunner.class) +public class ParametersReaderForMethodTest { + + @Test + @Parameters + public void oneParamDifferentTypes(int number, String a) { + assertThat(number).isEqualTo(1); + assertThat(a).isEqualTo("a"); + } + + private Object[] parametersForOneParamDifferentTypes() { + return new Object[]{1, "a"}; + } + + @Test + @Parameters + public void oneParamSetOneNull(String a, String b) { + assertThat(a).isNull(); + assertThat(b).isEqualTo("b"); + } + + private Object[] parametersForOneParamSetOneNull() { + return new Object[]{null, "b"}; + } + + @Test + @Parameters + public void noToString(NoToStringObject o) { + assertThat(o).isNotNull(); + } + + private Object[] parametersForNoToString() { + return new Object[]{new NoToStringObject()}; + } + + public class NoToStringObject { + } + + @Test + @Parameters + public void shouldIgnoreWhenEmptyParamset() { + fail(); + } + + private Object[] parametersForShouldIgnoreWhenEmptyParamset() { + return new Object[] {}; + } + + @Test + @Parameters({ "a \n \\,\\|b", "\\,a(asdf)\\|", "\\,", "", "\r\n" }) + public void escapedSpecialCharsInParam(String a) { + assertThat(a). + isIn("a \n ,|b", ",a(asdf)|", ",", ""). + isNotIn("a \n \\,\\|b", "\\,a(asdf)\\|", "\\,", "\r\n"); + } +} diff --git a/src/test/java/junitparams/ParametersReaderProvidersTest.java b/src/test/java/junitparams/ParametersReaderProvidersTest.java new file mode 100644 index 0000000..d3992b6 --- /dev/null +++ b/src/test/java/junitparams/ParametersReaderProvidersTest.java @@ -0,0 +1,103 @@ +package junitparams; + +import junitparams.internal.ParameterisedTestMethodRunner; +import junitparams.internal.TestMethod; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.TestClass; + +import java.lang.reflect.Method; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(JUnitParamsRunner.class) +public class ParametersReaderProvidersTest { + + @Rule + public ExpectedException exception = ExpectedException.none(); + + @Test + @Parameters(source = SingleParamSetProvider.class) + public void oneParamSetFromClass(String a, String b) { + assertThat(a).isEqualTo("a"); + assertThat(b).isEqualTo("b"); + } + + public static class SingleParamSetProvider { + public static Object[] provideOneParamSetSameTypes() { + return new Object[]{"a", "b"}; + } + } + + @Test + public void shouldPutProviderClassNameInExceptionMessageForProviderWithNoValidMethods() { + ParameterisedTestMethodRunner runner = new ParameterisedTestMethodRunner(getTestMethodWithInvalidProvider()); + + exception.expect(RuntimeException.class); + exception.expectMessage(ProviderClassWithNoValidMethods.class.getName()); + runner.method.parametersSets(); + } + + private TestMethod getTestMethodWithInvalidProvider() { + Method testMethod = TestClassWithProviderClassWithNoValidMethods.class.getMethods()[0]; + return new TestMethod(new FrameworkMethod(testMethod), new TestClass(TestClassWithProviderClassWithNoValidMethods.class)); + } + + @RunWith(JUnitParamsRunner.class) + static class TestClassWithProviderClassWithNoValidMethods { + @Test + @Parameters(source = ProviderClassWithNoValidMethods.class) + public void shouldDoNothingItsJustToConnectTestClassWithProvider() { + } + } + + static class ProviderClassWithNoValidMethods { + } + + @Test + @Parameters(source = OneIntegerProvider.class) + public void providedPrimitiveParams(int integer) { + assertThat(integer).isLessThan(4); + } + + public static class OneIntegerProvider { + public static Object[] provideTwoNumbers() { + return new Object[]{new Object[]{1}, new Object[]{2}}; + } + + public static Object[] provideOneNumber() { + return new Object[]{new Object[]{3}}; + } + } + + @Test + @Parameters(source = DomainObjectProvider.class) + public void providedDomainParams(DomainClass object1, DomainClass object2) { + assertThat(object1.toString()).isEqualTo("testNameOne"); + assertThat(object2.toString()).isEqualTo("testNameTwo"); + } + + public static class DomainObjectProvider { + public static Object[] provideDomainObject() { + return new Object[]{new Object[]{ + new DomainClass("testNameOne"), + new DomainClass("testNameTwo")}}; + } + } + + public static class DomainClass { + private final String name; + + public DomainClass(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } + } +} diff --git a/src/test/java/junitparams/ParamsConverterTest.java b/src/test/java/junitparams/ParamsConverterTest.java new file mode 100644 index 0000000..0bdd5a1 --- /dev/null +++ b/src/test/java/junitparams/ParamsConverterTest.java @@ -0,0 +1,168 @@ +package junitparams; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Date; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.converters.ConversionFailedException; +import junitparams.converters.ConvertParam; +import junitparams.converters.Converter; +import junitparams.converters.Param; +import junitparams.converters.ParamConverter; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class ParamsConverterTest { + + @Test + @Parameters({"01.12.2012"}) + public void convertSingleParam( + @ConvertParam(value = StringToDateConverter.class, options = "dd.MM.yyyy") Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + @Test + @Parameters({"01.12.2012,A"}) + public void convertMultipleParams( + @ConvertParam(value = StringToDateConverter.class, options = "dd.MM.yyyy") Date date, + @ConvertParam(LetterToNumberConverter.class) int num) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + assertThat(num).isEqualTo(1); + } + + @Test + @Parameters(method = "params") + public void convertParamsFromMethod( + @ConvertParam(value = StringToDateConverter.class, options = "dd.MM.yyyy") Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + @Test + @Parameters({"01.12.2012"}) + public void convertParamsUsingParamAnnotation(@Param(converter = SimpleDateConverter.class) Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + @Test + @Parameters({"01.12.2012"}) + public void convertParamsUsingCustomParamAnnotation(@DateParam Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + @Test + @Parameters(method = "params") + public void convertParamsFromMethodUsingCustomParamAnnotation(@DateParam Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + private List<String> params() { + return Arrays.asList("01.12.2012"); + } + + @Test + @Parameters({"2012-12-01"}) + public void convertParamsUsingCustomParamAnnotationOverridingAttributes(@DateParam(format = "yyyy-MM-dd") Date date) { + Calendar calendar = createCalendarWithDate(date); + assertCalendarDate(calendar); + } + + @Test + @Parameters({"2012-12-01"}) + public void passesParametersWithOtherAnnotations(@Other String parameter) { + assertThat(parameter) + .isExactlyInstanceOf(String.class) + .isEqualTo("2012-12-01"); + } + + private void assertCalendarDate(Calendar calendar) { + assertThat(calendar.get(Calendar.YEAR)).isEqualTo(2012); + assertThat(calendar.get(Calendar.MONTH)).isEqualTo(11); + assertThat(calendar.get(Calendar.DAY_OF_MONTH)).isEqualTo(1); + } + + private Calendar createCalendarWithDate(Date date) { + Calendar calendar = Calendar.getInstance(); + calendar.setTime(date); + return calendar; + } + + public static class LetterToNumberConverter implements ParamConverter<Integer> { + public Integer convert(Object param, String options) { + return param.toString().charAt(0) - 64; + } + } + + public static class StringToDateConverter implements ParamConverter<Date> { + public Date convert(Object param, String options) { + try { + return new SimpleDateFormat(options).parse(param.toString()); + } catch (ParseException e) { + throw new RuntimeException(e); + } + } + } + + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.PARAMETER) + @Param(converter = FormattedDateConverter.class) + public @interface DateParam { + + String format() default "dd.MM.yyyy"; + } + + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.PARAMETER) + public @interface Other { + } + + public static class FormattedDateConverter implements Converter<DateParam, Date> { + + private String format; + + @Override + public void initialize(DateParam annotation) { + this.format = annotation.format(); + } + + @Override + public Date convert(Object param) throws ConversionFailedException { + try { + return new SimpleDateFormat(format).parse(param.toString()); + } catch (ParseException e) { + throw new ConversionFailedException("failed"); + } + } + } + + public static class SimpleDateConverter implements Converter<Param, Date> { + @Override + public void initialize(Param annotation) { + } + + @Override + public Date convert(Object param) throws ConversionFailedException { + try { + return new SimpleDateFormat("dd.MM.yyyy").parse(param.toString()); + } catch (ParseException e) { + throw new ConversionFailedException("failed"); + } + } + } +} diff --git a/src/test/java/junitparams/ParamsInAnnotationTest.java b/src/test/java/junitparams/ParamsInAnnotationTest.java new file mode 100644 index 0000000..57183a8 --- /dev/null +++ b/src/test/java/junitparams/ParamsInAnnotationTest.java @@ -0,0 +1,88 @@ +package junitparams; + +import java.math.BigDecimal; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class ParamsInAnnotationTest { + + @Test + @Parameters({"1", "2"}) + public void singleParam(int number) { + assertThat(number).isGreaterThan(0); + } + + @Test + @Parameters({"1, true", "2, false"}) + public void multipleParamsCommaSeparated(int number, boolean isOne) throws Exception { + if (isOne) + assertThat(number).isEqualTo(1); + else + assertThat(number).isNotEqualTo(1); + } + + @Test + @Parameters({"1 | true", "2 | false"}) + public void multipleParamsPipeSeparated(int number, boolean isOne) throws Exception { + if (isOne) + assertThat(number).isEqualTo(1); + else + assertThat(number).isNotEqualTo(1); + } + + @Test + @Parameters({"a \n b", "a(asdf)", "a \r a"}) + public void specialCharsInParam(String a) throws Exception { + assertThat(a).isIn("a \n b", "a(asdf)", "a \r a"); + } + + @Test + @Parameters({",1"}) + public void emptyFirstParam(String empty, int number) { + assertThat(empty).isEmpty(); + assertThat(number).isEqualTo(1); + } + + @Test + @Parameters({"1,"}) + public void emptyLastParam(int number, String empty) { + assertThat(empty).isEmpty(); + assertThat(number).isEqualTo(1); + } + + @Test + @Parameters({"1,,1"}) + public void emptyMiddleParam(int number1, String empty, int number2) { + assertThat(empty).isEmpty(); + assertThat(number1).isEqualTo(1); + assertThat(number2).isEqualTo(1); + } + + @Test + @Parameters({","}) + public void allParamsEmpty(String empty1, String empty2) { + assertThat(empty1).isEmpty(); + assertThat(empty2).isEmpty(); + } + + @Test + @Parameters({ + "1, 1, 1", + "1.1, 1.1, 2", + "11, 11, 2", + "1.11, 1.11, 3" + }) + public void convertToBigDecimal(BigDecimal number, String string, int precision) { + assertThat(number).isEqualByComparingTo(string); + assertThat(number.precision()).isEqualTo(precision); + } + + @Test(expected = IllegalArgumentException.class) + @Parameters({" invalidNumber "}) + public void cannotConvertToBigDecimalForInvalidInput(BigDecimal number) { + } +} diff --git a/src/test/java/junitparams/RulesTest.java b/src/test/java/junitparams/RulesTest.java new file mode 100644 index 0000000..3dde4cf --- /dev/null +++ b/src/test/java/junitparams/RulesTest.java @@ -0,0 +1,60 @@ +package junitparams; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ErrorCollector; +import org.junit.rules.ExpectedException; +import org.junit.rules.TemporaryFolder; +import org.junit.rules.TestName; +import org.junit.rules.TestRule; +import org.junit.rules.TestWatcher; +import org.junit.rules.Timeout; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class RulesTest { + @Rule + public TemporaryFolder folder = new TemporaryFolder(); + @Rule + public ExpectedException exception = ExpectedException.none(); + @Rule + public ErrorCollector errors = new ErrorCollector(); + @Rule + public TestName testName = new TestName(); + @Rule + public TestWatcher testWatcher = new TestWatcher() { + }; + @Rule + public Timeout timeout = new Timeout(0); + + + @Test + @Parameters("") + public void shouldHandleRulesProperly(String n) { + assertThat(testName.getMethodName()).isEqualTo("shouldHandleRulesProperly"); + } + + @Test + public void shouldProvideHelpfulExceptionMessageWhenRuleIsUsedImproperly() { + Result result = JUnitCore.runClasses(ProtectedRuleTest.class); + + assertThat(result.getFailureCount()).isEqualTo(1); + assertThat(result.getFailures().get(0).getException()) + .hasMessage("The @Rule 'testRule' must be public."); + } + + public class ProtectedRuleTest { + @Rule + TestRule testRule; + + @Test + public void test() { + + } + } + +} diff --git a/src/test/java/junitparams/SampleTestCase.java b/src/test/java/junitparams/SampleTestCase.java new file mode 100644 index 0000000..7b9e2b0 --- /dev/null +++ b/src/test/java/junitparams/SampleTestCase.java @@ -0,0 +1,24 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public class SampleTestCase { + + @Test + public void firstTestMethod() throws Exception { + + } + + @Test + @Parameters(method = "getParameters") + public void secondTestMethod(String parameter) throws Exception { + + } + + private Object[] getParameters() { + return new Object[]{"a", "b"}; + } + +} diff --git a/src/test/java/junitparams/SamplesOfUsageVerificationTest.java b/src/test/java/junitparams/SamplesOfUsageVerificationTest.java new file mode 100644 index 0000000..13a0719 --- /dev/null +++ b/src/test/java/junitparams/SamplesOfUsageVerificationTest.java @@ -0,0 +1,21 @@ +package junitparams; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; + +import junitparams.usage.SamplesOfUsageTest; + +public class SamplesOfUsageVerificationTest { + + @Test + public void verifyNoTestsIgnoredInSamplesOfUsageTest() { + Result result = JUnitCore.runClasses(SamplesOfUsageTest.class); + + assertEquals(0, result.getFailureCount()); + assertEquals(0, result.getIgnoreCount()); + } + +} diff --git a/src/test/java/junitparams/SubclassTest.java b/src/test/java/junitparams/SubclassTest.java new file mode 100644 index 0000000..ec2fb6d --- /dev/null +++ b/src/test/java/junitparams/SubclassTest.java @@ -0,0 +1,22 @@ +package junitparams; + +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assert.*; + +import org.junit.*; + +import junitparams.usage.person_example.PersonTest.*; + +public class SubclassTest extends SuperclassTest { + + @Test + @Parameters(method = "paramsForIsAdult") + public void isAdult(int age, boolean valid) throws Exception { + assertThat(new Person(age).isAdult(), is(valid)); + } + + @SuppressWarnings("unused") + private Object[] paramsForSuperclassMethod() { + return new Object[]{1}; + } +}
\ No newline at end of file diff --git a/src/test/java/junitparams/SuperclassTest.java b/src/test/java/junitparams/SuperclassTest.java new file mode 100644 index 0000000..f5987c5 --- /dev/null +++ b/src/test/java/junitparams/SuperclassTest.java @@ -0,0 +1,20 @@ +package junitparams; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public abstract class SuperclassTest { + + @Test + @Parameters(method = "paramsForSuperclassMethod") + public void testWork(int val) throws Exception { + assertThat(val).isGreaterThan(0); + } + + protected Object[] paramsForIsAdult() { + return new Object[]{new Object[]{11, false}, new Object[]{17, false}, new Object[]{18, true}, new Object[]{22, true}}; + } +}
\ No newline at end of file diff --git a/src/test/java/junitparams/WrongArgumentsNumberTest.java b/src/test/java/junitparams/WrongArgumentsNumberTest.java new file mode 100644 index 0000000..a0a28fc --- /dev/null +++ b/src/test/java/junitparams/WrongArgumentsNumberTest.java @@ -0,0 +1,14 @@ +package junitparams; + +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(JUnitParamsRunner.class) +public class WrongArgumentsNumberTest { + + @Test(expected = IllegalArgumentException.class) + @Parameters({"one"}) + public void throwsExceptionForWrongNumberOfParameters(String value, String notProvided) { + } + +} diff --git a/src/test/java/junitparams/converters/NullableConverterTest.java b/src/test/java/junitparams/converters/NullableConverterTest.java new file mode 100644 index 0000000..d023ce2 --- /dev/null +++ b/src/test/java/junitparams/converters/NullableConverterTest.java @@ -0,0 +1,52 @@ +package junitparams.converters; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class NullableConverterTest { + + @Test + @Parameters({"null"}) + public void shouldConvertToNull(@Nullable String value) { + assertThat(value).isNull(); + } + + @Test + @Parameters({" null"}) + public void shouldConvertToNullIgnoringWhitespaces(@Nullable String value) { + assertThat(value).isNull(); + } + + @Test + @Parameters({"A", "B"}) + public void shouldNotApplyConversionToNull(@Nullable String value) { + assertThat(value).isNotNull(); + } + + @Test + @Parameters({" #null "}) + public void shouldUseCustomNullIdentifier(@Nullable(nullIdentifier = "#null") String value) { + assertThat(value).isNull(); + } + + @Test + @Parameters({" null "}) + public void shouldIgnoreDefaultNulllIdentifierWhenIsSpecifiedCustomOne(@Nullable(nullIdentifier = "#null") String value) { + assertThat(value).isNotNull(); + } + + @Test + @Parameters({"A, B"}) + public void shouldNotApplyConversionToNull(@Nullable String firstParam, @Nullable String secondParam) { + assertThat(firstParam).isEqualTo("A"); + assertThat(secondParam).isEqualTo("B"); + } + + +} diff --git a/src/test/java/junitparams/custom/CustomParametersProviderTest.java b/src/test/java/junitparams/custom/CustomParametersProviderTest.java new file mode 100644 index 0000000..f9e2eee --- /dev/null +++ b/src/test/java/junitparams/custom/CustomParametersProviderTest.java @@ -0,0 +1,61 @@ +package junitparams.custom; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.JUnitParamsRunner; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class CustomParametersProviderTest { + + @Test + @CustomParameters(provider = SimpleHelloProvider.class) + public void runWithParametersFromCustomProvider(String param) { + assertThat(param).isEqualTo("hello"); + } + + @Test + @HelloParameters(hello = "Hi") + public void runWithParametersFromCustomAnnotation(String param) { + assertThat(param).isEqualTo("Hi"); + } + + + @Retention(RetentionPolicy.RUNTIME) + @CustomParameters(provider = CustomHelloProvider.class) + public @interface HelloParameters { + String hello(); + } + + public static class SimpleHelloProvider implements ParametersProvider<CustomParameters> { + @Override + public void initialize(CustomParameters parametersAnnotation) { + } + + @Override + public Object[] getParameters() { + return new Object[]{"hello", "hello"}; + } + } + + public static class CustomHelloProvider implements ParametersProvider<HelloParameters> { + + private String hello; + + @Override + public void initialize(HelloParameters parametersAnnotation) { + hello = parametersAnnotation.hello(); + } + + @Override + public Object[] getParameters() { + return new Object[]{hello, hello}; + } + } +} + diff --git a/src/test/java/junitparams/custom/combined/CartesianTest.java b/src/test/java/junitparams/custom/combined/CartesianTest.java new file mode 100644 index 0000000..e2fbb12 --- /dev/null +++ b/src/test/java/junitparams/custom/combined/CartesianTest.java @@ -0,0 +1,79 @@ +package junitparams.custom.combined; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Test; + +import static java.util.Collections.*; +import static org.assertj.core.api.Assertions.*; + +public class CartesianTest { + + @Test + public void shouldReturnEmptyWhenNoArgumentsPassed() { + // when + Object result[] = Cartesian.getCartesianProductOf(null); + + // then + assertThat(result).isEmpty(); + } + + @Test + public void shouldReturnInputWhenOneArgumentPassed() { + Object[] testArray = new String[]{"AAA", "BBB"}; + List<Object[]> list = singletonList(testArray); + + // when + Object result[] = Cartesian.getCartesianProductOf(list); + + // then + assertThat(result).isEqualTo(testArray); + } + + @Test + public void shouldReturnProductOfTwoArrays() { + Object[] testArrayOne = new String[]{"AAA", "BBB"}; + Object[] testArrayTwo = new Integer[]{1, 2}; + + List<Object[]> test = new ArrayList<Object[]>(); + test.add(testArrayOne); + test.add(testArrayTwo); + + Object[] expectedResult = new Object[][]{ + {"AAA", 1}, {"AAA", 2}, + {"BBB", 1}, {"BBB", 2}, + }; + + // when + Object result[] = Cartesian.getCartesianProductOf(test); + + // then + assertThat(result).isEqualTo(expectedResult); + } + + @Test + public void shouldReturnProductOfThreeArrays() { + Object[] testArrayOne = new String[]{"AAA", "BBB"}; + Object[] testArrayTwo = new Integer[]{1, 2}; + Object[] testArrayThree = new String[]{"XXX", "YYY"}; + + List<Object[]> test = new ArrayList<Object[]>(); + test.add(testArrayOne); + test.add(testArrayTwo); + test.add(testArrayThree); + + Object[] expectedResult = new Object[][]{ + {"AAA", 1, "XXX"}, {"AAA", 1, "YYY"}, + {"AAA", 2, "XXX"}, {"AAA", 2, "YYY"}, + {"BBB", 1, "XXX"}, {"BBB", 1, "YYY"}, + {"BBB", 2, "XXX"}, {"BBB", 2, "YYY"}, + }; + + // when + Object result[] = Cartesian.getCartesianProductOf(test); + + // then + assertThat(result).isEqualTo(expectedResult); + } +} diff --git a/src/test/java/junitparams/custom/combined/CombinedParametersProviderTest.java b/src/test/java/junitparams/custom/combined/CombinedParametersProviderTest.java new file mode 100644 index 0000000..f95494e --- /dev/null +++ b/src/test/java/junitparams/custom/combined/CombinedParametersProviderTest.java @@ -0,0 +1,88 @@ +package junitparams.custom.combined; + +import java.util.LinkedList; +import java.util.List; + +import org.junit.AfterClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.JUnitParamsRunner; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class CombinedParametersProviderTest { + + private static Verifier verifier = new Verifier(); + + @Test + @CombinedParameters({"a,b", "1,2"}) + public void calledWithCartesianProduct(String character, String number) { + verifier.called(character, number); + } + + @AfterClass + public static void verify() { + assertThat(verifier.getCalls()).containsOnly( + new Verifier.Call("a", "1"), + new Verifier.Call("b", "1"), + new Verifier.Call("a", "2"), + new Verifier.Call("b", "2") + ); + } + + private static class Verifier { + + private List<Call> calls = new LinkedList<Call>(); + + void called(String firstParam, String anotherParam){ + calls.add(new Call(firstParam, anotherParam)); + } + + List<Call> getCalls() { + return calls; + } + + private static class Call { + + private final String firstParam; + private final String anotherParam; + + Call(String firstParam, String anotherParam) { + this.firstParam = firstParam; + this.anotherParam = anotherParam; + } + + @Override + public String toString() { + return "Call{" + + "'" + firstParam + '\'' + + ",'" + anotherParam + '\'' + + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Call call = (Call) o; + + return firstParam.equals(call.firstParam) && anotherParam.equals(call.anotherParam); + + } + + @Override + public int hashCode() { + int result = firstParam.hashCode(); + result = 31 * result + anotherParam.hashCode(); + return result; + } + } + } +} diff --git a/src/test/java/junitparams/internal/TestMethodTest.java b/src/test/java/junitparams/internal/TestMethodTest.java new file mode 100644 index 0000000..2964781 --- /dev/null +++ b/src/test/java/junitparams/internal/TestMethodTest.java @@ -0,0 +1,155 @@ +package junitparams.internal; + +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.RunWith; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.TestClass; + +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; + +@RunWith(JUnitParamsRunner.class) +public class TestMethodTest { + TestMethod plainTestMethod; + TestMethod arrayTestMethod; + + @Before + public void setUp() throws Exception { + plainTestMethod = new TestMethod(new FrameworkMethod(TestMethodTest.class.getMethod("forOthersToWork", new Class[]{String.class})), + new TestClass(this.getClass())); + arrayTestMethod = new TestMethod(new FrameworkMethod(TestMethodTest.class.getMethod("forOthersToWorkWithArray", + new Class[]{(new String[]{}).getClass()})), + new TestClass(this.getClass())); + } + + @Test + @Parameters({"a","b"}) + public void forOthersToWork(String arg) throws Exception { + assertThat(arg).isIn("a","b"); + } + + + @Test + @Parameters({"a,b","b,a"}) + public void forOthersToWorkWithArray(String... arg) throws Exception { + assertThat(arg).containsOnlyOnce("a","b"); + } + + @Test + @Ignore + public void flatTestMethodStructure() throws Exception { + System.setProperty("JUnitParams.flat", "true"); + + Description description = plainTestMethod.describe(); + + assertEquals("for_others_to_work(junitparams.internal.TestMethodTest)", description.getDisplayName()); + assertTrue(description.getChildren().isEmpty()); + System.clearProperty("JUnitParams.flat"); + } + + + @Test + public void hierarchicalTestMethodStructure() throws Exception { + System.clearProperty("JUnitParams.flat"); + Description description = plainTestMethod.describe(); + + assertEquals("forOthersToWork", description.getDisplayName()); + assertEquals("[0] a (forOthersToWork)(junitparams.internal.TestMethodTest)", description.getChildren().get(0).getDisplayName()); + assertEquals("[1] b (forOthersToWork)(junitparams.internal.TestMethodTest)", description.getChildren().get(1).getDisplayName()); + } + + @Test + public void hierarchicalArrayTestMethodStructure() throws Exception { + System.clearProperty("JUnitParams.flat"); + Description description = arrayTestMethod.describe(); + + assertEquals("forOthersToWorkWithArray", description.getDisplayName()); + assertEquals("[0] a,b (forOthersToWorkWithArray)(junitparams.internal.TestMethodTest)", + description.getChildren().get(0).getDisplayName()); + assertEquals("[1] b,a (forOthersToWorkWithArray)(junitparams.internal.TestMethodTest)", + description.getChildren().get(1).getDisplayName()); + } + + @Test + @Parameters + public void testVarargs(String... strings){ + assertArrayEquals("Hello world".split(" "), strings); + } + + protected Object[] parametersForTestVarargs(){ + return new Object[]{ + new Object[]{"Hello", "world"} + }; + } + + @Test + @Parameters + public void testVarargsCustomClass(Pair... pairs){ + assertEquals(pairs[0].x, pairs[0].y); + assertEquals(pairs[1].x, pairs[1].y); + assertNotEquals(pairs[2].x, pairs[2].y); + } + + protected Object[] parametersForTestVarargsCustomClass(){ + return new Object[]{ + new Object[]{new Pair(0, 0), new Pair(1, 1), new Pair(2, 3)} + }; + } + + @Test + @Parameters + public void testVarargsMoreArgs(int sumOfX, int sumOfY, Pair... pairs){ + int sumOfXFromPairs = 0; + int sumOfYFromPairs = 0; + for (Pair pair : pairs) { + sumOfXFromPairs += pair.x; + sumOfYFromPairs += pair.y; + } + assertEquals(sumOfX, sumOfXFromPairs); + assertEquals(sumOfY, sumOfYFromPairs); + } + + protected Object parametersForTestVarargsMoreArgs(){ + return new Object[]{new Object[]{40, 50, new Pair(17, 21), new Pair(12, 18), new Pair(11, 11)}, new Object[]{10, 20, new Pair(3, + 15), new Pair(7, 5)}}; + } + + @Test + @Parameters + public void testVargsMoreArgsOfTheSameType(Pair sum, Pair... pairs) { + assertEquals(sum.x, pairs[0].x + pairs[1].x); + assertEquals(sum.y, pairs[0].y + pairs[1].y); + } + + protected Object parametersForTestVargsMoreArgsOfTheSameType(){ + return new Object[]{new Object[]{new Pair(10, 30), new Pair(7, 17), new Pair(3, 13)}, new Object[]{new Pair(20, 40), new Pair(18, + 21), new Pair(2, 19)}}; + } + + @Test + @Parameters(method = "nullArray") + public void varargsCheckPassesWithNullArray(boolean isNull, String... array) throws Exception { + assertEquals(isNull, array == null); + } + + private Object nullArray() { + return new Object[] { + new Object[] { false, new String[] { "1", "2" } }, + new Object[] { true, null }, + }; + } + + private class Pair{ + int x,y; + public Pair(int x, int y){ + this.x = x; + this.y = y; + } + } +} diff --git a/src/test/java/junitparams/internal/UtilsTest.java b/src/test/java/junitparams/internal/UtilsTest.java new file mode 100644 index 0000000..f5b9be1 --- /dev/null +++ b/src/test/java/junitparams/internal/UtilsTest.java @@ -0,0 +1,56 @@ +package junitparams.internal; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.Test; + +public class UtilsTest { + + @Test + public void shouldSafelyCastStringArrayParamSetToArray() { + // given + Object paramSet = new String[] {"this", "is", "a", "test"}; + + // when + Object[] result = Utils.safelyCastParamsToArray(paramSet); + + // then + assertThat(result).containsExactly("this", "is", "a", "test"); + } + + @Test + public void shouldSafelyCastIntegerArrayParamSetToArray() { + // given + Object paramSet = new Integer[] {1, 2, 3, 4}; + + // when + Object[] result = Utils.safelyCastParamsToArray(paramSet); + + // then + assertThat(result).containsExactly(1, 2, 3, 4); + } + + @Test + public void shouldSafelyCastArrayParamSetToArray() { + // given + Object paramSet = new Object[] {1, "2", 30D}; + + // when + Object[] result = Utils.safelyCastParamsToArray(paramSet); + + // then + assertThat(result).containsExactly(1, "2", 30D); + } + + @Test + public void shouldCreateSingletonArrayWhenCastingObjectToArray() { + // given + Object paramSet = "test"; + + // when + Object[] result = Utils.safelyCastParamsToArray(paramSet); + + // then + assertThat(result).containsExactly("test"); + } +} diff --git a/src/test/java/junitparams/naming/MacroSubstitutionNamingStrategyTest.java b/src/test/java/junitparams/naming/MacroSubstitutionNamingStrategyTest.java new file mode 100644 index 0000000..b6c5c5c --- /dev/null +++ b/src/test/java/junitparams/naming/MacroSubstitutionNamingStrategyTest.java @@ -0,0 +1,92 @@ +package junitparams.naming; + +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; +import junitparams.internal.TestMethod; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.TestClass; + +import java.lang.reflect.Method; + +import static org.junit.Assert.assertEquals; + +@RunWith(JUnitParamsRunner.class) +public class MacroSubstitutionNamingStrategyTest { + + public Object parametersForTestNaming() { + return new Object[]{new Object[]{"withoutTestCaseAnnotation", "[0] value (withoutTestCaseAnnotation)"}, + new Object[]{"withAnnotationWithoutTemplate", "[0] value (withAnnotationWithoutTemplate)"}, + new Object[]{"withEmptyTemplate", "[0] value (withEmptyTemplate)"}, + new Object[]{"whenTemplateResultedToEmptyName", "[0] value (whenTemplateResultedToEmptyName)"}, + new Object[]{"withoutMacro", "plain name"}, new Object[]{"withIndexMacro", "0"}, + new Object[]{"withParamsMacro", "value"}, + new Object[]{"withMethodNameMacro", "withMethodNameMacro"}, + new Object[]{"withCombinationOfMacros", "0: withCombinationOfMacros(value)"}, + new Object[]{"withMacroNameWrittenInDifferentCase", "value value value"}, + new Object[]{"withMethodParameterIndexInsideArgumentsArray", "value"}, + new Object[]{"withMethodParameterIndexOutsideArgumentsArray", "Here is 100 argument:"}, + new Object[]{"whenGivenMacroDoesntExist", "{not_existing_macro}"}}; + } + + @Test + @Parameters + public void testNaming(String methodName, String expectedTestCaseName) throws NoSuchMethodException { + TestCaseNamingStrategy strategy = createNamingStrategyForMethod(methodName, String.class); + + String name = strategy.getTestCaseName(0, new Object[]{"value"}); + + assertEquals(expectedTestCaseName, name); + } + + public void withoutTestCaseAnnotation(String param1) { } + + @TestCaseName("plain name") + public void withoutMacro(String param1) { } + + @TestCaseName("{index}") + public void withIndexMacro(String param1) { } + + @TestCaseName("{params}") + public void withParamsMacro(String param1) { } + + @TestCaseName("{method}") + public void withMethodNameMacro(String param1) { } + + @TestCaseName + public void withAnnotationWithoutTemplate(String param1) { } + + @TestCaseName("") + public void withEmptyTemplate(String param1) { } + + @TestCaseName("{index}: {method}({params})") + public void withCombinationOfMacros(String param1) { } + + @TestCaseName("{params} {PARAMS} {PaRams}") + public void withMacroNameWrittenInDifferentCase(String param1) { } + + @TestCaseName("{0}") + public void withMethodParameterIndexInsideArgumentsArray(String param1) { } + + @TestCaseName("Here is 100 argument:{100}") + public void withMethodParameterIndexOutsideArgumentsArray(String param1) { } + + @TestCaseName("{100}") + public void whenTemplateResultedToEmptyName(String param1) { } + + @TestCaseName("{not_existing_macro}") + public void whenGivenMacroDoesntExist(String param1) { } + + private TestCaseNamingStrategy createNamingStrategyForMethod(String name, Class... parameterTypes) throws NoSuchMethodException { + TestMethod method = getCurrentClassMethod(name, parameterTypes); + + return new MacroSubstitutionNamingStrategy(method); + } + + private TestMethod getCurrentClassMethod(String name, Class... parameterTypes) throws NoSuchMethodException { + final Method method = MacroSubstitutionNamingStrategyTest.class.getMethod(name, parameterTypes); + return new TestMethod(new FrameworkMethod(method), + new TestClass(this.getClass())); + } +} diff --git a/src/test/java/junitparams/naming/NamingStrategyIsUsedByRunnerTest.java b/src/test/java/junitparams/naming/NamingStrategyIsUsedByRunnerTest.java new file mode 100644 index 0000000..1e0ec24 --- /dev/null +++ b/src/test/java/junitparams/naming/NamingStrategyIsUsedByRunnerTest.java @@ -0,0 +1,48 @@ +package junitparams.naming; + +import org.junit.AfterClass; +import org.junit.Test; +import org.junit.runner.Description; +import org.junit.runner.Request; +import org.junit.runner.RunWith; + +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; + +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class NamingStrategyIsUsedByRunnerTest { + + @AfterClass + public static void checkTestCaseNames() { + Description rootDescription = getTestClassDescription(); + String className = "(" + NamingStrategyIsUsedByRunnerTest.class.getCanonicalName() + ")"; + + Description sampleMethodDescription = getChildDescriptionByName(rootDescription, "sampleMethod"); + + assertThat(sampleMethodDescription.getChildren()).extracting("displayName").containsExactly( + "[0] Well formed name of sampleMethod with param1" + className, + "[1] Well formed name of sampleMethod with param2" + className); + } + + @Test + @Parameters({"param1", "param2"}) + @TestCaseName("[{index}] Well formed name of {method} with {params}") + public void sampleMethod(String parameter) { + } + + private static Description getTestClassDescription() { + return Request.aClass(NamingStrategyIsUsedByRunnerTest.class).getRunner().getDescription(); + } + + private static Description getChildDescriptionByName(Description parent, String expectedName) { + for (Description childDescription : parent.getChildren()) { + if (expectedName.equals(childDescription.getDisplayName())) { + return childDescription; + } + } + + return null; + } +} diff --git a/src/test/java/junitparams/usage/SamplesOfUsageTest.java b/src/test/java/junitparams/usage/SamplesOfUsageTest.java new file mode 100644 index 0000000..5ce425d --- /dev/null +++ b/src/test/java/junitparams/usage/SamplesOfUsageTest.java @@ -0,0 +1,159 @@ +package junitparams.usage; + +import java.util.Arrays; +import java.util.Date; +import java.util.Iterator; +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import junitparams.FileParameters; +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; +import junitparams.ParametersReaderProvidersTest; +import junitparams.ParamsConverterTest; +import junitparams.converters.Param; +import junitparams.custom.combined.CombinedParameters; +import junitparams.mappers.CsvWithHeaderMapper; +import junitparams.naming.TestCaseName; +import junitparams.usage.person_example.PersonMapper; +import junitparams.usage.person_example.PersonTest; +import junitparams.usage.person_example.PersonType; + +import static junitparams.JUnitParamsRunner.*; +import static org.assertj.core.api.Assertions.*; + +@RunWith(JUnitParamsRunner.class) +public class SamplesOfUsageTest { + + @Test + @Parameters({"AAA,1", "BBB,2"}) + public void paramsInAnnotation(String p1, Integer p2) { } + + @Test + @Parameters({"AAA|1", "BBB|2"}) + public void paramsInAnnotationPipeSeparated(String p1, Integer p2) { } + + @Test + @Parameters + public void paramsInDefaultMethod(String p1, Integer p2) { } + private Object parametersForParamsInDefaultMethod() { + return new Object[]{new Object[]{"AAA", 1}, new Object[]{"BBB", 2}}; + } + + @Test + @Parameters(method = "named1") + public void paramsInNamedMethod(String p1, Integer p2) { } + private Object named1() { + return new Object[]{"AAA", 1}; + } + + @Test + @Parameters(method = "named2,named3") + public void paramsInMultipleMethods(String p1, Integer p2) { } + private Object named2() { + return new Object[]{"AAA", 1}; + } + private Object named3() { + return new Object[]{"BBB", 2}; + } + + @Test + @Parameters(method = "named4") + public void paramsWithVarargs(String... args) { + assertThat(args).isEqualTo(new String[]{"AAA", "BBB"}); + } + private Object named4() { return new Object[]{new String[]{"AAA", "BBB"}}; } + + @Test + @Parameters(source = ParametersReaderProvidersTest.OneIntegerProvider.class) + public void paramsFromExternalClass(int integer) { } + + @Test + @Parameters + public void paramsInCollection(String p1) { } + private List<String> parametersForParamsInCollection() { return Arrays.asList("a"); } + + @Test + @Parameters + public void paramsInIterator(String p1) { } + private Iterator<String> parametersForParamsInIterator() { return Arrays.asList("a").iterator(); } + + @Test + @Parameters({"SOME_VALUE", "OTHER_VALUE"}) + public void enumsAsParamInAnnotation(PersonType person) { } + + @Test + @Parameters + public void enumsAsParamsInMethod(PersonType person) { } + private PersonType[] parametersForEnumsAsParamsInMethod() { return (PersonType[]) new PersonType[] {PersonType.SOME_VALUE}; } + + @Test + @Parameters(source = PersonType.class) + public void enumAsSource(PersonType personType) { + } + + @Test + @Parameters + public void wrapParamsWithConstructor(PersonTest.Person person) { } + private Object parametersForWrapParamsWithConstructor() { + return new Object[]{new Object[]{"first", 1}, new Object[]{"second", 2}}; + } + + @Test + @FileParameters("src/test/resources/test.csv") + public void loadParamsFromCsv(int age, String name) { } + + @Test + @FileParameters(value = "src/test/resources/test.csv", mapper = PersonMapper.class) + public void loadParamsFromAnyFile(PersonTest.Person person) { } + + @Test + @FileParameters("classpath:test.csv") + public void loadParamsFromClasspath(int age, String name) { } + + @Test + @FileParameters(value = "classpath:with_header.csv", mapper = CsvWithHeaderMapper.class) + public void loadParamsFromCsvWithHeader(int id, String name) { } + + @Test + @Parameters({ "01.12.2012" }) + public void convertParams(@Param(converter = ParamsConverterTest.SimpleDateConverter.class) Date date) {} + + @Test + @Parameters("please\\, escape commas if you use it here and don't want your parameters to be splitted") + public void commasInParametersUsage(String phrase) { } + + @Test + @Parameters({ "1,1", "2,2", "3,6" }) + @TestCaseName("factorial({0}) = {1}") + public void customNamesForTestCase(int argument, int result) { } + + @Test + @Parameters({ "value1, value2", "value3, value4" }) + @TestCaseName("[{index}] {method}: {params}") + public void predefinedMacroForTestCaseNames(String param1, String param2) { } + + public Object mixedParameters() { + boolean booleanValue = true; + int[] primitiveArray = {1, 2, 3}; + String stringValue = "Test"; + String[] stringArray = {"one", "two", null}; + return $( + $(booleanValue, primitiveArray, stringValue, stringArray) + ); + } + + @Test + @Parameters(method = "mixedParameters") + @TestCaseName("{0}, {1}, {2}, {3}") + public void usageOfMultipleTypesOfParameters( + boolean booleanValue, int[] primitiveArray, String stringValue, String[] stringArray) { + } + + @Test + @CombinedParameters({"AAA,BBB", "1|2"}) + public void combineParamsInAnnotation(String p1, Integer p2) {} + +} diff --git a/src/test/java/junitparams/usage/person_example/PersonMapper.java b/src/test/java/junitparams/usage/person_example/PersonMapper.java new file mode 100644 index 0000000..24ed212 --- /dev/null +++ b/src/test/java/junitparams/usage/person_example/PersonMapper.java @@ -0,0 +1,21 @@ +package junitparams.usage.person_example; + +import java.io.*; +import java.util.*; + +import junitparams.internal.*; +import junitparams.mappers.*; + +public class PersonMapper extends CsvWithHeaderMapper { + @Override + public Object[] map(Reader reader) { + Object[] map = super.map(reader); + List<Object[]> result = new LinkedList<Object[]>(); + for (Object lineObj : map) { + String line = (String) lineObj; + result.add(new Object[] { line.substring(2), Integer.parseInt(line.substring(0, 1)) }); + } + return result.toArray(); + } + +}
\ No newline at end of file diff --git a/src/test/java/junitparams/usage/person_example/PersonTest.java b/src/test/java/junitparams/usage/person_example/PersonTest.java new file mode 100644 index 0000000..927204e --- /dev/null +++ b/src/test/java/junitparams/usage/person_example/PersonTest.java @@ -0,0 +1,97 @@ +package junitparams.usage.person_example; + +import static org.assertj.core.api.Assertions.assertThat; + +import junitparams.naming.TestCaseName; +import org.junit.*; +import org.junit.runner.*; + +import junitparams.*; + +@RunWith(JUnitParamsRunner.class) +public class PersonTest { + + @Test + @Parameters({ + "17, false", + "22, true" }) + public void isAdultAgeDirect(int age, boolean valid) throws Exception { + assertThat(new Person(age).isAdult()).isEqualTo(valid); + } + + @Test + @Parameters(method = "adultValues") + public void isAdultAgeDefinedMethod(int age, boolean valid) throws Exception { + assertThat(new Person(age).isAdult()).isEqualTo(valid); + } + + private Object[] adultValues() { + return new Object[]{new Object[]{17, false}, new Object[]{22, true}}; + } + + @Test + @Parameters + public void isAdultAgeDefaultMethod(int age, boolean valid) throws Exception { + assertThat(new Person(age).isAdult()).isEqualTo(valid); + } + + @SuppressWarnings("unused") + private Object[] parametersForIsAdultAgeDefaultMethod() { + return adultValues(); + } + + @Test + @Parameters(source = PersonProvider.class) + public void personIsAdult(Person person, boolean valid) { + assertThat(person.isAdult()).isEqualTo(valid); + } + + public static class PersonProvider { + public static Object[] provideAdults() { + return new Object[]{new Object[]{new Person(25), true}, new Object[]{new Person(32), true}}; + } + + public static Object[] provideTeens() { + return new Object[]{new Object[]{new Person(12), false}, new Object[]{new Person(17), false}}; + } + } + + @Test + @Parameters(method = "adultValues") + @TestCaseName("Is person with age {0} adult? It's {1} statement.") + public void isAdultWithCustomTestName(int age, boolean valid) throws Exception { + assertThat(new Person(age).isAdult()).isEqualTo(valid); + } + + public static class Person { + + private String name; + private int age; + + public Person(Integer age) { + this.age = age; + } + + public Person(String name, Integer age) { + this.name = name; + this.age = age; + } + + public String getName() { + return name; + } + + public boolean isAdult() { + return age >= 18; + } + + public int getAge() { + return age; + } + + @Override + public String toString() { + return "Person of age: " + age; + } + } +}
\ No newline at end of file diff --git a/src/test/java/junitparams/usage/person_example/PersonType.java b/src/test/java/junitparams/usage/person_example/PersonType.java new file mode 100644 index 0000000..cdc834f --- /dev/null +++ b/src/test/java/junitparams/usage/person_example/PersonType.java @@ -0,0 +1,5 @@ +package junitparams.usage.person_example; + +public enum PersonType { + SOME_VALUE, OTHER_VALUE +} |