How do you create parameterized tests in JUnit?

Table of Contents

• Introduction
• Creating Parameterized Tests with JUnit 5
  • 1. The @ParameterizedTest Annotation
    • Basic Example: Using @ValueSource
      • Example: Using @ValueSource for Parameterized Tests
  • 2. Using @MethodSource for More Complex Data
    • Example: Using @MethodSource for Complex Parameters
  • 3. Using @CsvSource for Multiple Parameters
    • Example: Using @CsvSource for Multiple Parameters
  • 4. Using @CsvFileSource for External CSV Files
    • Example: Using @CsvFileSource for External CSV Files
  • 5. Combining Multiple Sources with @ParameterizedTest
    • Example: Combining @CsvSource and @MethodSource
• Conclusion

Introduction

In JUnit, a parameterized test allows you to run the same test method multiple times with different sets of input data. This is particularly useful for validating code that operates on various inputs, as it eliminates the need for writing multiple test methods for similar logic. JUnit 5 provides powerful annotations, such as @ParameterizedTest, @ValueSource, @MethodSource, and @CsvSource, to simplify creating and running parameterized tests.

In this guide, we'll walk through the process of creating parameterized tests in JUnit 5, demonstrating how to use different sources of data to run tests with multiple inputs.

Creating Parameterized Tests with JUnit 5

1. The @ParameterizedTest Annotation

In JUnit 5, to define a parameterized test, you first need to use the @ParameterizedTest annotation. This annotation marks a test method as parameterized, meaning it will run multiple times with different arguments.

Basic Example: Using @ValueSource

The simplest way to provide parameters is using the @ValueSource annotation. This annotation allows you to provide a single value (like integers, strings, or booleans) that will be passed to the test method.

Example: Using @ValueSource for Parameterized Tests

In this example:

• The @ParameterizedTest annotation tells JUnit that this test will be parameterized.
• The @ValueSource(ints = {1, 2, 3}) annotation provides a set of integers to the test method.
• The test will run three times, once with each value (1, 2, and 3).

2. Using @MethodSource for More Complex Data

While @ValueSource is great for simple cases, you might need more complex parameters, such as objects, arrays, or combinations of different types. For this, you can use the @MethodSource annotation, which allows you to provide the parameters from a static method that returns a stream or collection of arguments.

Example: Using @MethodSource for Complex Parameters

In this example:

• The @MethodSource("provideStringsForTest") annotation tells JUnit to use the static method provideStringsForTest() to supply test data.
• The method provideStringsForTest() returns a stream of strings that will be passed as parameters to the test method.

3. Using @CsvSource for Multiple Parameters

If you want to test methods that take multiple parameters, you can use the @CsvSource annotation. It allows you to provide comma-separated values to the test method.

Example: Using @CsvSource for Multiple Parameters

In this example:

• The @CsvSource annotation provides multiple sets of input values in a CSV format.
• The test method receives two parameters: int id and String name, which correspond to the values from the CSV source.

4. Using @CsvFileSource for External CSV Files

If you have a large set of test data that is stored in an external CSV file, you can use the @CsvFileSource annotation to load the data from that file.

Example: Using @CsvFileSource for External CSV Files

In this example:

• The @CsvFileSource annotation loads the test data from an external CSV file (/testdata.csv).
• numLinesToSkip = 1 tells JUnit to skip the first line, which is often used for headers in CSV files.

5. Combining Multiple Sources with @ParameterizedTest

You can also combine multiple data sources to provide more complex test data. For example, you could combine @CsvSource and @MethodSource to provide different types of data to your test.

Example: Combining @CsvSource and @MethodSource

In this example:

• The test method receives data from both the @CsvSource and @MethodSource annotations.
• This allows you to combine different types of test data into a single parameterized test.

Conclusion

Parameterized tests in JUnit 5 provide a powerful mechanism to run a single test method with multiple sets of input data. This not only simplifies writing repetitive tests but also ensures that your code is validated against various input scenarios without duplicating test logic. With annotations like @ValueSource, @MethodSource, @CsvSource, and @CsvFileSource, JUnit makes it easy to create flexible and comprehensive parameterized tests, improving the efficiency and coverage of your unit tests.