Junit5参数化实战，让测试更优雅

<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-params -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

package top.caituotuo.demo;

import java.util.HashMap;
import java.util.Map;

/**
 * author: 测试蔡坨坨
 * datetime: 2023-8-21 02:12:43
 * function: 给定一个字符串，找出不含有重复字符的最长子串的长度。
 * 例如：
 * 给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，长度为 3。
 * 给定 "bbbbb" ，最长的子串就是 "b" ，长度是 1。
 * 给定 "pwwkew" ，最长的子串是 "wke" ，长度是 3。
 * 请注意答案必须是一个子串，"pwke" 是子序列 而不是子串。
 */

public class DemoTest {
    public int lengthOfLongestSubstr(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        // 定义dp数组的含义：以字符s[i]结尾时，不重复的子串长度为dp[i]
        int[] dp = new int[s.length()];
        // 初始值
        dp[0] = 1;
        Map<Character, Integer> map = new HashMap<>();
        map.put(s.charAt(0), 0);
        int maxLen = 1;
        int startIndex = 0;
        // 状态转换关系式
        for (int i = 1; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i))) {
                dp[i] = dp[i - 1] + 1;
            } else {
                int k = map.get(s.charAt(i));
                dp[i] = i - k <= dp[i - 1] ? i - k : dp[i - 1] + 1;
            }
            // maxLen = Math.max(maxLen, dp[i]);
            if (dp[i] > maxLen) {
                maxLen = dp[i];
                startIndex = i - maxLen + 1;
            }
            map.put(s.charAt(i), i);
        }
        System.out.printf("原字符串：%s，最长不重复子串：%s，长度：%s%n", s, s.substring(startIndex, startIndex + maxLen), maxLen);
        return maxLen;
    }
}

/**
 * @param s 测试方法中声明形参，代表参数化通过这个形参给到测试方法去使用
 */
// @Test
// 将@Test注解换成@ParameterizedTest注解，指明参数化测试用例
@ParameterizedTest
// 单参数注解，示例中为String类型参数化
@ValueSource(strings = {"abcabcbb", "pwwkew"})
public void test(String s) {
    assertEquals(3, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
@NullSource
@EmptySource
public void test0(String s) {
    assertEquals(0, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
@NullAndEmptySource
public void test1(String s) {
    assertEquals(0, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
// 传递的参数格式是一个集合，如果是多个参数，使用默认分隔符","分开
@CsvSource({"abcabcbb,3", "bbbbb,1"})
public void test2(String s, int n) {
    assertEquals(n, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
// 使用delimiterString指定分隔符，使用value指定数据源
@CsvSource(value = {"abcabcbb|3", "bbbbb|1"}, delimiterString = "|")
public void test3(String s, int n) {
    assertEquals(n, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
// 指定分隔符为“测试蔡坨坨”
@CsvSource(value = {"abcabcbb测试蔡坨坨3", "bbbbb测试蔡坨坨1"}, delimiterString = "测试蔡坨坨")
public void test4(String s, int n) {
    assertEquals(n, new DemoTest().lengthOfLongestSubstr(s));
}

@ParameterizedTest
@CsvFileSource(resources = "/data.csv", numLinesToSkip = 1, delimiterString = "-")
public void test5(String s, int n) {
    assertEquals(n, new DemoTest().lengthOfLongestSubstr(s));
}

package top.caituotuo.demo;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;

/**
 * author: 测试蔡坨坨
 * datetime: 2023/8/26 16:38
 * function: 单参数方法
 */
public class MethodSourceTest {
    /**
     * @param name 添加形参，形参的类型要和静态方法内部的元素类型一致
     */
    @ParameterizedTest
    // 通过@MethodSource注解指定数据源的方法名
    @MethodSource("stringProvider")
    void test1(String name) {
        System.out.println(name);
    }

    /**
     * 定义一个静态方法，提供参数化数据源
     *
     * @return 返回Stream流
     */
    static Stream<String> stringProvider() {
        return Stream.of("测试蔡坨坨", "小趴蔡", "IT小学生蔡坨坨");
    }
}

@ParameterizedTest
@MethodSource("range")
void testWithRangeMethodSource(int argument) {
    assertNotEquals(9, argument);
}
static IntStream range() {
    return IntStream.range(0, 20).skip(10);
}

package top.caituotuo.demo;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

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

/**
 * author: 测试蔡坨坨
 * datetime: 2023/8/22 23:32
 * function: 给出一个包含3个数字的列表，判断此3个数字能否组成三角形。能的话输出true，不能的话输出false。
 * 输入[3,4,3] 输出true
 * 输入[1,2,3] 输出false
 */
public class DemoTest {
    public boolean isTriangle(List<Integer> sides) {
        if (sides.size() != 3) {
            return false;
        }

        return sides.stream().allMatch(side -> side > 0) &&
                IntStream.range(0, 3).allMatch(i ->
                        sides.get(i) + sides.get((i + 1) % 3) > sides.get((i + 2) % 3));
    }

    @ParameterizedTest
    @MethodSource({"getTestSides"})
    public void test(List<Integer> sides, boolean expectedResult) {
        assertEquals(expectedResult, new DemoTest().isTriangle(sides));
    }

    static Stream<Arguments> getTestSides() {
        return Stream.of(
                Arguments.of(Arrays.asList(3, 4, 3), true),
                Arguments.of(Arrays.asList(1, 2, 3), false),
                Arguments.of(Arrays.asList(-3, 4, 5), false),
                Arguments.of(Arrays.asList(3, 4, 5, 6), false)
        );
    }
}