目录

JUnit

JUnitJUnitJUnit 5这篇JUnit5的文章

sumJUnit 5

GitHub上的一个可工作的示例代码。

    <groupId>org.junit.jupiter</groupId>

    <artifactId>junit-jupiter-params</artifactId>

    <version>5.9.2</version>

    <scope>test</scope>

@ParameterizedTest

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.params.ParameterizedTest;

import org.junit.jupiter.params.provider.ValueSource;

public class ValueSourceTest {

    @ParameterizedTest

    @ValueSource(ints = { 2, 4 })

    void checkEvenNumber(int number) {

        assertEquals(0, number % 2,

         "Supplied number is not an even number");

    }

@ValueSourcecheckEvenNumber()

ValueSourceTest

|_ checkEvenNumber

|_ [1] 2

|_ [2] 4

checkEvenNumber()

@ValueSource@ValueSourceshortbyteintlongfloatdoublecharbooleanStringClass

@ValueSource(strings = { "a1", "b2" })

void checkAlphanumeric(String word) {

    assertTrue(StringUtils.isAlphanumeric(word),

             "Supplied word is not alpha-numeric");

void checkNull(String value) {

    assertEquals(null, value);

void checkEmpty(String value) {

    assertEquals("", value);

void checkNullAndEmpty(String value) {

    assertTrue(value == null || value.isEmpty());

@ValueSource(strings = { " ", " " })

void checkNullEmptyAndBlank(String value) {

    assertTrue(value == null || value.isBlank());

void checkExplicitMethodSource(String word) {

assertTrue(StringUtils.isAlphanumeric(word),

"Supplied word is not alpha-numeric");

static Stream<String> checkExplicitMethodSourceArgs() {

return Stream.of("a1",

"b2");

void checkImplicitMethodSource(String word) {

    assertTrue(StringUtils.isAlphanumeric(word),

"Supplied word is not alpha-numeric");

static Stream<String> checkImplicitMethodSource() {

return Stream.of("a1",

"b2");

void checkMultiArgumentsMethodSource(int number, String expected) {

    assertEquals(StringUtils.equals(expected, "even") ? 0 : 1, number % 2);

static Stream<Arguments> checkMultiArgumentsMethodSource() {

    return Stream.of(Arguments.of(2, "even"),

     Arguments.of(3, "odd"));

void checkExternalMethodSource(String word) {

    assertTrue(StringUtils.isAlphanumeric(word),

"Supplied word is not alpha-numeric");

package source.method;

import java.util.stream.Stream;

public class ExternalMethodSource {

    static Stream<String> checkExternalMethodSourceArgs() {

        return Stream.of("a1",

         "b2");

    }

useHeadersInDisplayName

@CsvSource({ "2, even",

"3, odd"})

void checkCsvSource(int number, String expected) {

    assertEquals(StringUtils.equals(expected, "even")

     ? 0 : 1, number % 2);

numLinesToSkipuseHeadersInDisplayNamelineSeparatordelimiterString

files = "src/test/resources/csv-file-source.csv",

numLinesToSkip = 1)

void checkCsvFileSource(int number, String expected) {

    assertEquals(StringUtils.equals(expected, "even")

                 ? 0 : 1, number % 2);

NUMBER, ODD_EVEN

2, even

3, odd

    files = "src/test/resources/csv-file-source_attributes.csv",

    delimiterString = "|",

    lineSeparator = "||",

    numLinesToSkip = 1)

void checkCsvFileSourceAttributes(int number, String expected) {

    assertEquals(StringUtils.equals(expected, "even")

? 0 : 1, number % 2);

|| NUMBER | ODD_EVEN ||

|| 2      | even ||

|| 3      | odd     ||

package java.time.temporal;

public enum ChronoUnit implements TemporalUnit {

    SECONDS("Seconds", Duration.ofSeconds(1)),

    MINUTES("Minutes", Duration.ofSeconds(60)),

HOURS("Hours", Duration.ofSeconds(3600)),

    DAYS("Days", Duration.ofSeconds(86400)),

    //12 other units

@EnumSource(ChronoUnit.class)

void checkEnumSourceValue(ChronoUnit unit) {

assertNotNull(unit);

@EnumSource(names = { "DAYS", "HOURS" })

void checkEnumSourceNames(ChronoUnit unit) {

    assertNotNull(unit);

ArgumentsProviderArgumentsProvider

public class ArgumentsSourceTest {

    @ParameterizedTest

    @ArgumentsSource(ExternalArgumentsProvider.class)

    void checkExternalArgumentsSource(int number, String expected) {

        assertEquals(StringUtils.equals(expected, "even")

                    ? 0 : 1, number % 2,

                    "Supplied number " + number +

                    " is not an " + expected + " number");

    }

public class ExternalArgumentsProvider implements ArgumentsProvider {

    @Override

    public Stream<? extends Arguments> provideArguments(

        ExtensionContext context) throws Exception {

        return Stream.of(Arguments.of(2, "even"),

             Arguments.of(3, "odd"));

    }

public class ArgumentsSourceTest {

    @ParameterizedTest

    @ArgumentsSource(NestedArgumentsProvider.class)

    void checkNestedArgumentsSource(int number, String expected) {

        assertEquals(StringUtils.equals(expected, "even")

? 0 : 1, number % 2,

                 "Supplied number " + number +

                    " is not an " + expected + " number");

    }

    static class NestedArgumentsProvider implements ArgumentsProvider {

        @Override

        public Stream<? extends Arguments> provideArguments(

            ExtensionContext context) throws Exception {

            return Stream.of(Arguments.of(2, "even"),

     Arguments.of(3, "odd"));

        }

    }

public int sum(int a, int b) {

    return a + b;

@CsvSource({ "10, 5, 15" })

void calculateSum(String num1, String num2, String expected) {

    int actual = calculator.sum(Integer.parseInt(num1),

                                Integer.parseInt(num2));

    assertEquals(Integer.parseInt(expected), actual);

StringIntegers

@ValueSource(ints = { 2, 4 })

void checkWideningArgumentConversion(long number) {

    assertEquals(0, number % 2);

@ValueSource(ints = { 1, 2, 3 })

@ValueSource(strings = "DAYS")

void checkImplicitArgumentConversion(ChronoUnit argument) {

    assertNotNull(argument.name());

@ValueSource(strings = "DAYS")ChronoUnit

@ValueSource(strings = { "Name1", "Name2" })

void checkImplicitFallbackArgumentConversion(Person person) {

    assertNotNull(person.getName());

public class Person {

    private String name;

    public Person(String name) {

        this.name = name;

    }

    //Getters & Setters

@ValueSource(strings = { "Name1", "Name2" })Personname

@ValueSource(ints = { 100 })

void checkExplicitArgumentConversion(

    @ConvertWith(StringSimpleArgumentConverter.class) String argument) {

    assertEquals("100", argument);

public class StringSimpleArgumentConverter extends SimpleArgumentConverter {

    @Override

    protected Object convert(Object source, Class<?> targetType)

        throws ArgumentConversionException {

        return String.valueOf(source);

    }

@ConvertWith@ValueSource(ints = { 100 })StringSimpleArgumentConverter.class

@ParameterizedTestArgumentsAccessor

@CsvSource({ "John, 20",

         "Harry, 30" })

void checkArgumentsAccessor(ArgumentsAccessor arguments) {

    Person person = new Person(arguments.getString(0),

                             arguments.getInteger(1));

    assertTrue(person.getAge() > 19, person.getName() + " is a teenager");

ArgumentsAccessor

@CsvSource({ "John, 20",

             "Harry, 30" })

void checkArgumentsAggregator(

    @AggregateWith(PersonArgumentsAggregator.class) Person person) {

    assertTrue(person.getAge() > 19, person.getName() + " is a teenager");

public class PersonArgumentsAggregator implements ArgumentsAggregator {

    @Override

    public Object aggregateArguments(ArgumentsAccessor arguments,

        ParameterContext context) throws ArgumentsAggregationException {

        return new Person(arguments.getString(0),

arguments.getInteger(1));

    }

ArgumentsAggregator@AggregateWith

Fluent assertions for javajava.util.function.Consumer

void checkNumber(int number, Consumer<Integer> consumer) {

    consumer.accept(number);    

static Stream<Arguments> checkNumberArgs() {    

    Consumer<Integer> evenConsumer =

            i -> Assertions.assertThat(i % 2).isZero();

    Consumer<Integer> oddConsumer =

            i -> Assertions.assertThat(i % 2).isEqualTo(1);

    return Stream.of(Arguments.of(2, evenConsumer),

         Arguments.of(3, oddConsumer));

【注】本文译自： JUnit 5 Parameterized Tests (reflectoring.io)