JUnit 5 的参数化测试是什么？@ParameterizedTest、@ValueSource、@CsvSource 怎么用？

简化版

**参数化测试（Parameterized Test）是「用不同的输入数据，反复运行同一个测试方法」——比如测一个「判断是否质数」的方法，你想用 2、3、5、7、9、10 等多个值分别测，不用写 6 个测试方法，用参数化测试一个方法 + 一组数据搞定。**JUnit 5 用 @ParameterizedTest（替代 @Test）标记参数化测试方法，配合「参数来源」注解提供数据：① @ValueSource——提供一组单个值（@ValueSource(ints = {2, 3, 5, 7})，方法带一个参数）；② @CsvSource——提供多组「逗号分隔的值」（@CsvSource({"1, 2, 3", "4, 5, 9"})，每行一组、方法带多个参数，适合「输入 + 期望」的用例）；③ @MethodSource——用一个方法返回数据流（复杂对象、动态数据）；④ @EnumSource（枚举值）、@CsvFileSource（CSV 文件）等。好处：用少量代码测大量用例（尤其边界值、多种输入组合），覆盖更全、更简洁。核心：参数化测试用一个方法 + 多组数据反复运行，@ParameterizedTest + @ValueSource（单值）/@CsvSource（多值/输入+期望）/@MethodSource（复杂数据）提供数据。

详细版

参数来源注解：

注解	提供的数据	适合
@ValueSource	一组单值（ints/strings/…）	单参数、简单值
@CsvSource	多组逗号分隔值	多参数、输入+期望
@CsvFileSource	CSV 文件的数据	大量数据、外部维护
@MethodSource	方法返回的 Stream	复杂对象、动态数据
@EnumSource	枚举的值	枚举
@NullAndEmptySource	null 和空	边界（null/空字符串）

// @ValueSource：一组单值
@ParameterizedTest
@ValueSource(ints = {2, 3, 5, 7, 11})
void testPrime(int number) {
    assertTrue(isPrime(number));    // 每个值跑一次
}

// @CsvSource：多组值（输入 + 期望）
@ParameterizedTest
@CsvSource({
    "2, 3, 5",       // add(2, 3) 应该 = 5
    "10, 20, 30",
    "-1, 1, 0"
})
void testAdd(int a, int b, int expected) {
    assertEquals(expected, calc.add(a, b));   // 每行跑一次
}

// @MethodSource：复杂对象/动态数据
@ParameterizedTest
@MethodSource("userProvider")
void testUser(User user, boolean expectedValid) {
    assertEquals(expectedValid, validator.isValid(user));
}
static Stream<Arguments> userProvider() {
    return Stream.of(
        Arguments.of(new User("Tom", 18), true),
        Arguments.of(new User("", 18), false),
        Arguments.of(new User("Tom", -1), false)
    );
}

// @NullAndEmptySource + @ValueSource：测边界（null、空、空白）
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = {" ", "  "})
void testBlank(String input) {
    assertTrue(isBlank(input));   // null、""、" "、"  " 都跑
}

⚠️ 参数化测试的价值是「用一个方法覆盖大量用例，尤其是边界值和多种输入组合」——它让「测得全」变得低成本。手写测试时，测一个方法的多种输入（正常值、边界值、异常值）往往要写很多个几乎一样的测试方法（只有输入不同），繁琐且重复；参数化测试把「测试逻辑」和「测试数据」分离——测试逻辑写一次，数据用注解列一堆，就能覆盖所有用例。选择哪个数据源：@ValueSource（一个参数、简单值，如测多个数字）；@CsvSource（多个参数、尤其「输入 + 期望结果」的用例，如 add(2,3)=5）；@MethodSource（数据是复杂对象、或需要动态生成，用方法返回 Stream<Arguments>）；@NullAndEmptySource（专门测 null 和空的边界，很实用）。特别适合测边界值——一个方法配上「正常值、边界值、null、空、极值」一堆数据，一次覆盖所有边界。所以参数化测试是「提升测试覆盖率、减少重复代码」的利器。

完整版教学

一、问题：重复的测试方法

先理解参数化测试解决的问题：

测一个方法的多种输入（不用参数化）：
  测 isPrime（判断质数）用多个值：
    @Test void test2() { assertTrue(isPrime(2)); }
    @Test void test3() { assertTrue(isPrime(3)); }
    @Test void test4() { assertFalse(isPrime(4)); }
    @Test void test5() { assertTrue(isPrime(5)); }
    ...
  → 每个值一个测试方法，几乎一样（只有值不同）
  → 繁琐、重复、难维护（加个用例要加个方法）

问题：
  测试逻辑一样，只是输入不同
  → 写很多个重复的测试方法（样板代码）

想要的：
  测试逻辑写一次，用不同数据反复运行
  → 一个方法 + 一堆数据 → 覆盖所有用例

参数化测试的方案：
  @ParameterizedTest 标记方法（替代 @Test）
  + 参数来源（@ValueSource 等）提供数据
  → 同一个方法，每组数据跑一次
  → 测试逻辑和数据分离

所以参数化测试解决:重复的测试方法(逻辑同、只输入不同)

参数化测试解决的问题——测一个方法的多种输入不用参数化时，每个值一个测试方法（几乎一样只有值不同、繁琐重复难维护）。问题：测试逻辑一样只是输入不同、写很多重复的测试方法。想要的：测试逻辑写一次、用不同数据反复运行（一个方法+一堆数据覆盖所有用例）。参数化测试方案：@ParameterizedTest 标记方法（替代 @Test）+ 参数来源提供数据（同一方法每组数据跑一次、逻辑和数据分离）。理解「参数化测试解决重复测试方法(逻辑同只输入不同、繁琐重复);想要逻辑写一次用不同数据反复运行;方案 @ParameterizedTest+参数来源(逻辑和数据分离)」，就理解了参数化测试解决的问题。

二、@ValueSource：一组单值

@ValueSource——提供一组单个值：

@ValueSource：提供一组单个值（方法带一个参数）
  @ParameterizedTest
  @ValueSource(ints = {2, 3, 5, 7, 11})
  void testPrime(int number) {
    assertTrue(isPrime(number));   // 每个值跑一次
  }
  → 5 个值 → 跑 5 次（number 分别是 2、3、5、7、11）

支持的类型：
  ints、longs、doubles、floats、chars、booleans、shorts、bytes
  strings、classes
  @ValueSource(strings = {"a", "bb", "ccc"})

特点：
  ① 一个参数（方法只带一个参数）
  ② 简单值（基本类型、字符串）

适合：
  测一个方法对多个简单输入的行为
  如：多个数字、多个字符串

局限：
  ① 只能一个参数（多参数用 @CsvSource）
  ② 只能简单值（复杂对象用 @MethodSource）
  ③ 不能测"输入+期望"（值都是输入，期望要方法里算）
     → 输入+期望用 @CsvSource

所以 @ValueSource 提供一组单值(一个参数、简单值)

@ValueSource 提供一组单个值（方法带一个参数）——@ValueSource(ints = {2,3,5,7,11}) 每个值跑一次。支持类型：ints/longs/doubles/strings 等。特点：一个参数、简单值。适合：测一个方法对多个简单输入的行为。局限：只能一个参数（多参数用 @CsvSource）、只能简单值（复杂对象用 @MethodSource）、不能测输入+期望（用 @CsvSource）。理解「@ValueSource 一组单值(方法带一个参数)、支持 ints/strings 等;一个参数简单值;局限:只能一个参数(多参数 @CsvSource)、只能简单值(复杂 @MethodSource)、不能测输入+期望」，就掌握了 @ValueSource。

三、@CsvSource：多组值

@CsvSource——提供多组逗号分隔的值，适合「输入+期望」：

@CsvSource：提供多组"逗号分隔的值"（方法带多个参数）
  @ParameterizedTest
  @CsvSource({
    "2, 3, 5",       // 一组：a=2, b=3, expected=5
    "10, 20, 30",
    "-1, 1, 0"
  })
  void testAdd(int a, int b, int expected) {
    assertEquals(expected, calc.add(a, b));   // 每行跑一次
  }
  → 每行是一组数据（逗号分隔）→ 映射到方法的多个参数

特点：
  ① 多个参数（每行的值映射到方法参数）
  ② 适合"输入 + 期望"的用例
     → 前几个是输入、最后一个是期望结果
     → 一行就是一个完整的测试用例

处理特殊值：
  空字符串：'' 或不写
  null：@CsvSource(nullValues = "NULL")，然后用 NULL
  含逗号的值：用单引号包 "'a,b', c"
  分隔符：@CsvSource(delimiter = ';')

@CsvFileSource（数据在 CSV 文件）：
  @CsvFileSource(resources = "/data.csv")
  → 数据放外部 CSV 文件（大量数据、非开发人员维护）

适合：
  ① 多参数的用例
  ② "输入 → 期望"的用例（最常见，如加法、转换）
  ③ 一行一个测试用例（清晰）

所以 @CsvSource 提供多组值(多参数、输入+期望,一行一个用例)

@CsvSource 提供多组逗号分隔的值（方法带多个参数）——@CsvSource({"2, 3, 5", ...}) 每行一组数据映射到方法参数、每行跑一次。特点：多个参数、适合「输入+期望」用例（前几个输入、最后一个期望结果、一行就是一个完整用例）。特殊值：空字符串 ''、null（nullValues）、含逗号用单引号包、自定义分隔符。@CsvFileSource（数据在 CSV 文件、大量数据/外部维护）。适合：多参数用例、输入→期望用例（最常见）、一行一个测试用例。理解「@CsvSource 多组逗号分隔值(多参数)、适合输入+期望(前几个输入最后期望、一行一个用例);特殊值空/null/含逗号;@CsvFileSource 数据在文件」，就掌握了 @CsvSource。

四、@MethodSource：复杂数据

@MethodSource——用方法返回数据流，处理复杂对象：

@MethodSource：用一个方法提供数据（复杂对象、动态数据）
  @ParameterizedTest
  @MethodSource("userProvider")
  void testUser(User user, boolean expectedValid) {
    assertEquals(expectedValid, validator.isValid(user));
  }
  // 提供数据的方法（返回 Stream<Arguments>）
  static Stream<Arguments> userProvider() {
    return Stream.of(
      Arguments.of(new User("Tom", 18), true),
      Arguments.of(new User("", 18), false),
      Arguments.of(new User("Tom", -1), false)
    );
  }
  → 方法返回的每个 Arguments 是一组参数

特点：
  ① 能提供复杂对象（User、List 等，不只是简单值）
  ② 能动态生成数据（在方法里计算、从数据库/文件读）
  ③ 返回 Stream<Arguments>（每个 Arguments 一组参数）

Arguments.of(参数1, 参数2, ...)：构造一组参数

适合：
  ① 数据是复杂对象（@ValueSource/@CsvSource 只能简单值）
  ② 数据要动态生成、或来自外部（数据库、文件、计算）
  ③ 大量数据、复杂用例

方法要求：
  static（默认，除非用 @TestInstance(PER_CLASS)）
  返回 Stream/Collection/Iterator of Arguments

所以 @MethodSource 用方法返回数据流(复杂对象、动态数据)

@MethodSource 用一个方法提供数据（复杂对象、动态数据）——@MethodSource("userProvider") + 方法返回 Stream<Arguments>（每个 Arguments.of(...) 一组参数）。特点：能提供复杂对象（User/List 不只简单值）、能动态生成数据（方法里计算、从数据库/文件读）、返回 Stream。适合：数据是复杂对象、数据要动态生成/来自外部、大量数据复杂用例。方法要求 static（默认）、返回 Stream/Collection of Arguments。理解「@MethodSource 用方法返回数据流(复杂对象/动态数据)、返回 Stream(每个 Arguments.of 一组参数);适合复杂对象/动态生成/外部数据;方法 static 返回 Stream of Arguments」，就掌握了 @MethodSource。

五、其他数据源与边界测试

补充其他数据源，尤其边界测试：

其他数据源：
  @EnumSource（枚举）：
    @EnumSource(Status.class)
    void test(Status status) { ... }  // 每个枚举值跑一次
    → 测所有枚举值

  @NullSource / @EmptySource / @NullAndEmptySource（边界）：
    @NullSource：提供 null
    @EmptySource：提供空（"" / 空集合 / 空数组）
    @NullAndEmptySource：null + 空
    → 专门测 null 和空的边界（很实用）

  @CsvFileSource（CSV 文件）：
    数据放 CSV 文件（大量数据、外部维护）

组合数据源（多个注解）：
  @ParameterizedTest
  @NullAndEmptySource            // null、空
  @ValueSource(strings = {" ", "\t"})  // 空白字符
  void testBlank(String s) {
    assertTrue(isBlank(s));   // null、""、" "、"\t" 都测
  }
  → 组合多个数据源（覆盖 null、空、空白）

参数化测试特别适合边界测试：
  一个方法 + "正常值、边界值、null、空、极值" 一堆数据
  → 一次覆盖所有边界（提升覆盖率）

命名（测试报告）：
  @ParameterizedTest(name = "{0} + {1} = {2}")
  → 自定义每个用例的显示名（清晰）

所以还有 @EnumSource/@NullAndEmptySource 等,特别适合边界测试

其他数据源：@EnumSource（枚举，测所有枚举值）、@NullSource/@EmptySource/@NullAndEmptySource（专门测 null 和空的边界，很实用）、@CsvFileSource（CSV 文件）。组合数据源（多个注解组合覆盖 null/空/空白）。参数化测试特别适合边界测试（一个方法+正常值/边界值/null/空/极值一堆数据、一次覆盖所有边界）。命名（name 自定义用例显示名）。理解「其他数据源:@EnumSource(枚举)/@NullAndEmptySource(测 null 和空边界很实用)/@CsvFileSource;组合数据源覆盖 null/空/空白;特别适合边界测试(一个方法+一堆边界数据);name 自定义用例名」，就掌握了其他数据源与边界测试。

六、实践与总结

总结参数化测试的实践：

选择数据源：
  一个参数、简单值 → @ValueSource
  多个参数、输入+期望 → @CsvSource
  复杂对象、动态数据 → @MethodSource
  枚举值 → @EnumSource
  测 null/空边界 → @NullAndEmptySource
  大量数据、外部文件 → @CsvFileSource

实践建议：
  ① 用参数化测试覆盖多个用例（尤其边界值、多种输入）
     → 测得全、代码少
  ② 输入+期望的用例用 @CsvSource（一行一个用例，清晰）
  ③ 复杂对象用 @MethodSource
  ④ 边界测试用 @NullAndEmptySource + @ValueSource 组合
  ⑤ 用 name 自定义用例名（报告清晰）

好处总结：
  ① 减少重复代码（一个方法测多个用例）
  ② 提升覆盖率（容易覆盖边界值、多种输入）
  ③ 测试逻辑和数据分离（好维护）
  ④ 加用例只加数据（不用加方法）

核心总结：
  参数化测试 = 一个方法 + 多组数据反复运行
  @ParameterizedTest + @ValueSource(单值)/@CsvSource(多值/输入+期望)
    /@MethodSource(复杂对象)/@NullAndEmptySource(边界)
  减少重复、提升覆盖、逻辑和数据分离
  特别适合边界值和多种输入组合

参数化测试选择数据源：一个参数简单值→@ValueSource、多参数输入+期望→@CsvSource、复杂对象→@MethodSource、枚举→@EnumSource、null/空边界→@NullAndEmptySource、外部文件→@CsvFileSource。实践：覆盖多个用例(尤其边界)、输入+期望用 @CsvSource、复杂对象用 @MethodSource、边界用 @NullAndEmptySource 组合、name 自定义用例名。好处：减少重复+提升覆盖+逻辑数据分离+加用例只加数据。理解「选择:单值 @ValueSource/多值 @CsvSource/复杂 @MethodSource/枚举 @EnumSource/边界 @NullAndEmptySource;实践覆盖边界+输入期望用 CsvSource+复杂用 MethodSource;好处减少重复+提升覆盖+逻辑数据分离」，就掌握了实践与总结。

记忆钩子：「参数化测试=一个方法+多组数据反复运行(解决重复测试方法,逻辑和数据分离);@ParameterizedTest(替代 @Test)标记+参数来源提供数据:①@ValueSource(ints={2,3,5})一组单值(一个参数简单值)②@CsvSource({‘2,3,5’})多组逗号分隔值(多参数、适合输入+期望、一行一个用例)③@MethodSource(‘provider’)用方法返回 Stream(复杂对象/动态数据,Arguments.of(…)一组参数)④@EnumSource(枚举)⑤@NullAndEmptySource(测 null 和空边界很实用)⑥@CsvFileSource(CSV 文件);好处减少重复代码+提升覆盖率(容易覆盖边界值多种输入)+逻辑数据分离;特别适合边界测试(一个方法+正常/边界/null/空/极值一堆数据一次覆盖)」。

七、常见误区与追问

误区：测一个方法的多种输入要写多个测试方法。 用参数化测试——@ParameterizedTest 标记方法 + 参数来源（@ValueSource/@CsvSource/@MethodSource）提供多组数据，同一个方法用每组数据跑一次；测试逻辑写一次、数据用注解列一堆，覆盖所有用例，减少重复代码。
误区：@ValueSource 能提供多个参数或复杂对象。 @ValueSource 只能提供一组单个的简单值（ints/strings 等），方法只能带一个参数；要多个参数用 @CsvSource（逗号分隔的多个值）；要复杂对象用 @MethodSource（方法返回 Stream）。
误区：参数化测试的 @CsvSource 只能放简单的输入。 @CsvSource 特别适合「输入 + 期望结果」的用例——每行是一组数据（逗号分隔），前几个值是输入、最后一个是期望结果，一行就是一个完整的测试用例（如 “2, 3, 5” 表示 add(2,3) 应该等于 5）；比只放输入更有用。
误区：参数化测试和普通测试没什么区别。 参数化测试的价值是「用一个方法覆盖大量用例、尤其边界值和多种输入组合」——把测试逻辑和测试数据分离，测试逻辑写一次、数据用注解列，容易覆盖正常值、边界值、null、空、极值等；加用例只加数据、不用加方法；显著减少重复代码、提升覆盖率。
追问：JUnit 5 的参数化测试怎么用？ 用 @ParameterizedTest 标记测试方法（替代 @Test），配合参数来源注解提供数据：@ValueSource（一组单值，如 @ValueSource(ints = {2,3,5})，方法带一个参数）、@CsvSource（多组逗号分隔的值，如 @CsvSource({“2,3,5”})，每行一组、方法带多个参数，适合输入+期望）、@MethodSource（用一个方法返回 Stream，适合复杂对象或动态数据）、@EnumSource（枚举值）、@NullAndEmptySource（测 null 和空）；同一个测试方法用每组数据跑一次，减少重复代码、提升覆盖率。
追问：@ValueSource、@CsvSource、@MethodSource 分别什么时候用？ @ValueSource：方法只有一个参数、数据是简单值（基本类型、字符串），如测多个数字是否质数；@CsvSource：方法有多个参数、尤其「输入 + 期望结果」的用例（前几个是输入、最后一个是期望），如 add(2,3)=5，一行一个用例；@MethodSource：数据是复杂对象（User、List）、或需要动态生成（从数据库/文件读、计算），用一个方法返回 Stream（每个 Arguments.of(…) 是一组参数）。
追问：参数化测试适合测什么？ 特别适合测边界值和多种输入组合——一个方法配上「正常值、边界值、null、空字符串、极值（最大最小）、非法值」一堆数据，一次覆盖所有边界和情况；比如测一个校验方法，用 @NullAndEmptySource + @ValueSource 覆盖 null、空、空白、正常值；用少量代码测大量用例，显著提升测试覆盖率，是提升测试质量的利器。

八、加强记忆

参数化测试（Parameterized Test）= 用不同的输入数据反复运行同一个测试方法——解决「测一个方法的多种输入要写多个几乎一样的测试方法」的重复问题，把测试逻辑和测试数据分离。JUnit 5 用 @ParameterizedTest（替代 @Test） 标记方法，配合参数来源注解提供数据：① @ValueSource（一组单值，@ValueSource(ints = {2,3,5})，一个参数、简单值）；② @CsvSource（多组逗号分隔的值，@CsvSource({"2, 3, 5"})，多参数、适合「输入 + 期望」用例、一行一个用例）；③ @MethodSource（用一个方法返回 Stream<Arguments>，复杂对象、动态数据，Arguments.of(...) 一组参数）；④ @EnumSource（枚举值）；⑤ @NullAndEmptySource（专门测 null 和空的边界，很实用）；⑥ @CsvFileSource（CSV 文件）。好处：减少重复代码（一个方法测多个用例）、提升覆盖率（容易覆盖边界值和多种输入）、测试逻辑和数据分离、加用例只加数据。特别适合边界测试（一个方法配「正常值、边界值、null、空、极值」一堆数据、一次覆盖）。一句话「参数化测试=一个方法+多组数据反复运行(逻辑和数据分离);@ParameterizedTest+@ValueSource(单值)/@CsvSource(多值/输入+期望一行一用例)/@MethodSource(复杂对象/动态数据)/@NullAndEmptySource(边界);减少重复+提升覆盖率,特别适合边界值和多种输入」。

简化版

详细版