Migrate to JUnit5

interpreter/src/test/java/com/iluwatar/interpreter/AppTest.java

@@ -22,7 +22,7 @@
  */
 package com.iluwatar.interpreter;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * 

interpreter/src/test/java/com/iluwatar/interpreter/ExpressionTest.java

@@ -22,15 +22,19 @@
  */
 package com.iluwatar.interpreter;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.IntBinaryOperator;
+import java.util.stream.Stream;
 
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
  * Date: 12/14/15 - 11:48 AM
@@ -45,37 +49,22 @@ public abstract class ExpressionTest<E extends Expression> {
    * Generate inputs ranging from -10 to 10 for both input params and calculate the expected result
    *
    * @param resultCalc The function used to calculate the expected result
-   * @return A data set with test entries
+   * @return A stream with test entries
    */
-  static List<Object[]> prepareParameters(final IntBinaryOperator resultCalc) {
-    final List<Object[]> testData = new ArrayList<>();
+  static Stream<Arguments> prepareParameters(final IntBinaryOperator resultCalc) {
+    final List<Arguments> testData = new ArrayList<>();
     for (int i = -10; i < 10; i++) {
       for (int j = -10; j < 10; j++) {
-        testData.add(new Object[]{
-            new NumberExpression(i),
-            new NumberExpression(j),
-            resultCalc.applyAsInt(i, j)
-        });
+        testData.add(Arguments.of(
+                new NumberExpression(i),
+                new NumberExpression(j),
+                resultCalc.applyAsInt(i, j)
+        ));
       }
     }
-    return testData;
+    return testData.stream();
   }
 
-  /**
-   * The input used as first parameter during the test
-   */
-  private final NumberExpression first;
-
-  /**
-   * The input used as second parameter during the test
-   */
-  private final NumberExpression second;
-
-  /**
-   * The expected result of the calculation, taking the first and second parameter in account
-   */
-  private final int result;
-
   /**
    * The expected {@link E#toString()} response
    */
@@ -89,47 +78,34 @@ public abstract class ExpressionTest<E extends Expression> {
   /**
    * Create a new test instance with the given parameters and expected results
    *
-   * @param first            The input used as first parameter during the test
-   * @param second           The input used as second parameter during the test
-   * @param result           The expected result of the tested expression
    * @param expectedToString The expected {@link E#toString()} response
    * @param factory          Factory, used to create a new test object instance
    */
-  ExpressionTest(final NumberExpression first, final NumberExpression second, final int result,
-                 final String expectedToString, final BiFunction<NumberExpression, NumberExpression, E> factory) {
-
-    this.first = first;
-    this.second = second;
-    this.result = result;
+  ExpressionTest(final String expectedToString,
+                 final BiFunction<NumberExpression, NumberExpression, E> factory
+  ) {
     this.expectedToString = expectedToString;
     this.factory = factory;
   }
 
-  /**
-   * Get the first parameter
-   *
-   * @return The first parameter
-   */
-  final NumberExpression getFirst() {
-    return this.first;
-  }
-
   /**
    * Verify if the expression calculates the correct result when calling {@link E#interpret()}
    */
-  @Test
-  public void testInterpret() {
-    final E expression = this.factory.apply(this.first, this.second);
+  @ParameterizedTest
+  @MethodSource("expressionProvider")
+  public void testInterpret(NumberExpression first, NumberExpression second, int result) {
+    final E expression = factory.apply(first, second);
     assertNotNull(expression);
-    assertEquals(this.result, expression.interpret());
+    assertEquals(result, expression.interpret());
   }
 
   /**
    * Verify if the expression has the expected {@link E#toString()} value
    */
-  @Test
-  public void testToString() {
-    final E expression = this.factory.apply(this.first, this.second);
+  @ParameterizedTest
+  @MethodSource("expressionProvider")
+  public void testToString(NumberExpression first, NumberExpression second) {
+    final E expression = factory.apply(first, second);
     assertNotNull(expression);
     assertEquals(expectedToString, expression.toString());
   }

interpreter/src/test/java/com/iluwatar/interpreter/MinusExpressionTest.java

@@ -22,18 +22,15 @@
  */
 package com.iluwatar.interpreter;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.provider.Arguments;
 
-import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Date: 12/14/15 - 12:08 PM
  *
  * @author Jeroen Meulemeester
  */
-@RunWith(Parameterized.class)
 public class MinusExpressionTest extends ExpressionTest<MinusExpression> {
 
   /**
@@ -41,20 +38,15 @@ public class MinusExpressionTest extends ExpressionTest<MinusExpression> {
    *
    * @return The list of parameters used during this test
    */
-  @Parameters
-  public static List<Object[]> data() {
+  public static Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f - s);
   }
 
   /**
    * Create a new test instance using the given test parameters and expected result
-   *
-   * @param first  The first expression parameter
-   * @param second The second expression parameter
-   * @param result The expected result
    */
-  public MinusExpressionTest(final NumberExpression first, final NumberExpression second, final int result) {
-    super(first, second, result, "-", MinusExpression::new);
+  public MinusExpressionTest() {
+    super("-", MinusExpression::new);
   }
 
 }

interpreter/src/test/java/com/iluwatar/interpreter/MultiplyExpressionTest.java

@@ -22,18 +22,15 @@
  */
 package com.iluwatar.interpreter;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.provider.Arguments;
 
-import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Date: 12/14/15 - 12:08 PM
  *
  * @author Jeroen Meulemeester
  */
-@RunWith(Parameterized.class)
 public class MultiplyExpressionTest extends ExpressionTest<MultiplyExpression> {
 
   /**
@@ -41,20 +38,16 @@ public class MultiplyExpressionTest extends ExpressionTest<MultiplyExpression> {
    *
    * @return The list of parameters used during this test
    */
-  @Parameters
-  public static List<Object[]> data() {
+  public static Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f * s);
   }
 
   /**
    * Create a new test instance using the given test parameters and expected result
    *
-   * @param first  The first expression parameter
-   * @param second The second expression parameter
-   * @param result The expected result
    */
-  public MultiplyExpressionTest(final NumberExpression first, final NumberExpression second, final int result) {
-    super(first, second, result, "*", MultiplyExpression::new);
+  public MultiplyExpressionTest() {
+    super("*", MultiplyExpression::new);
   }
 
 }

interpreter/src/test/java/com/iluwatar/interpreter/NumberExpressionTest.java

@@ -22,21 +22,19 @@
  */
 package com.iluwatar.interpreter;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
-import java.util.List;
+import java.util.stream.Stream;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Date: 12/14/15 - 12:08 PM
  *
  * @author Jeroen Meulemeester
  */
-@RunWith(Parameterized.class)
 public class NumberExpressionTest extends ExpressionTest<NumberExpression> {
 
   /**
@@ -44,30 +42,26 @@ public class NumberExpressionTest extends ExpressionTest<NumberExpression> {
    *
    * @return The list of parameters used during this test
    */
-  @Parameters
-  public static List<Object[]> data() {
+  public static Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f);
   }
 
   /**
    * Create a new test instance using the given test parameters and expected result
-   *
-   * @param first  The first expression parameter
-   * @param second The second expression parameter
-   * @param result The expected result
    */
-  public NumberExpressionTest(final NumberExpression first, final NumberExpression second, final int result) {
-    super(first, second, result, "number", (f, s) -> f);
+  public NumberExpressionTest() {
+    super("number", (f, s) -> f);
   }
 
   /**
    * Verify if the {@link NumberExpression#NumberExpression(String)} constructor works as expected
    */
-  @Test
-  public void testFromString() throws Exception {
-    final int expectedValue = getFirst().interpret();
-    final String testStingValue = String.valueOf(expectedValue);
-    final NumberExpression numberExpression = new NumberExpression(testStingValue);
+  @ParameterizedTest
+  @MethodSource("expressionProvider")
+  public void testFromString(NumberExpression first) throws Exception {
+    final int expectedValue = first.interpret();
+    final String testStringValue = String.valueOf(expectedValue);
+    final NumberExpression numberExpression = new NumberExpression(testStringValue);
     assertEquals(expectedValue, numberExpression.interpret());
   }
 

interpreter/src/test/java/com/iluwatar/interpreter/PlusExpressionTest.java

@@ -22,18 +22,15 @@
  */
 package com.iluwatar.interpreter;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.provider.Arguments;
 
-import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Date: 12/14/15 - 12:08 PM
  *
  * @author Jeroen Meulemeester
  */
-@RunWith(Parameterized.class)
 public class PlusExpressionTest extends ExpressionTest<PlusExpression> {
 
   /**
@@ -41,20 +38,15 @@ public class PlusExpressionTest extends ExpressionTest<PlusExpression> {
    *
    * @return The list of parameters used during this test
    */
-  @Parameters
-  public static List<Object[]> data() {
+  public static Stream<Arguments> expressionProvider() {
     return prepareParameters((f, s) -> f + s);
   }
 
   /**
    * Create a new test instance using the given test parameters and expected result
-   *
-   * @param first  The first expression parameter
-   * @param second The second expression parameter
-   * @param result The expected result
    */
-  public PlusExpressionTest(final NumberExpression first, final NumberExpression second, final int result) {
-    super(first, second, result, "+", PlusExpression::new);
+  public PlusExpressionTest() {
+    super("+", PlusExpression::new);
   }
 
 }