4.14日总结

今天继续做junit测试，判断闰年设计测试

编写程序判断闰年，设计测试⽤例并⽤Junit进⾏测试。

闰年判断程序

package org.example;

public class LeapYearChecker {
    /**
            * 判断给定年份是否为闰年
     * 闰年规则：
            * 1. 能被4整除但不能被100整除，是闰年
     * 2. 能被400整除，是闰年
     * @param year 要判断的年份
     * @return 如果是闰年返回true，否则返回false
     */
    public static boolean isLeapYear(int year) {
        if (year <= 0) {
            throw new IllegalArgumentException("年份必须大于0");
        }
        return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
    }
}

JUnit测试类

 

package org.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;

class LeapYearCheckerTest {

    // 普通测试用例
    @Test
    void testNormalLeapYears() {
        assertTrue(LeapYearChecker.isLeapYear(2000));
        assertTrue(LeapYearChecker.isLeapYear(2020));
        assertTrue(LeapYearChecker.isLeapYear(2400));
    }

    @Test
    void testNormalNonLeapYears() {
        assertFalse(LeapYearChecker.isLeapYear(1900));
        assertFalse(LeapYearChecker.isLeapYear(2021));
        assertFalse(LeapYearChecker.isLeapYear(2100));
    }

    // 边界值测试
    @Test
    void testBoundaryValues() {
        assertTrue(LeapYearChecker.isLeapYear(4)); // 第一个闰年
        assertFalse(LeapYearChecker.isLeapYear(1)); // 第一个非闰年
    }

    // 异常测试
    @Test
    void testInvalidYear() {
        assertThrows(IllegalArgumentException.class, () -> LeapYearChecker.isLeapYear(0));
        assertThrows(IllegalArgumentException.class, () -> LeapYearChecker.isLeapYear(-1));
        assertThrows(IllegalArgumentException.class, () -> LeapYearChecker.isLeapYear(-100));
    }

    // 参数化测试 - 使用CsvSource
    @ParameterizedTest(name = "年份 {0} 是闰年: {1}")
    @CsvSource({
            "2000, true",   // 能被400整除
            "2004, true",   // 能被4整除但不能被100整除
            "1900, false",  // 能被100整除但不能被400整除
            "2001, false",  // 普通非闰年
            "2400, true",   // 能被400整除
            "2100, false"   // 能被100整除但不能被400整除
    })
    void parameterizedTestWithCsvSource(int year, boolean expected) {
        assertEquals(expected, LeapYearChecker.isLeapYear(year));
    }

    // 参数化测试 - 使用ValueSource测试异常情况
    @ParameterizedTest
    @ValueSource(ints = {0, -1, -4, -100, -400})
    void parameterizedTestInvalidYears(int year) {
        assertThrows(IllegalArgumentException.class, () -> LeapYearChecker.isLeapYear(year));
    }
}

 

测试用例设计

1. 普通闰年测试用例

2000年（能被400整除）

2020年（能被4整除但不能被100整除）

2400年（能被400整除）

2. 普通非闰年测试用例

1900年（能被100整除但不能被400整除）

2021年（不能被4整除）

2100年（能被100整除但不能被400整除）

3. 边界值测试用例

4年（第一个闰年）

1年（第一个非闰年）

4. 异常情况测试用例

0年

负数年份（-1, -4, -100, -400）

5. 参数化测试用例

使用CsvSource提供多组输入和预期输出

使用ValueSource提供多组非法输入

测试覆盖率

所有闰年判断逻辑分支

异常处理分支

所有边界情况