4.24
实验四 单元测试2
一、实验目的
1、掌握单元测试的基本理论和作用。
2、掌握典型单元测试工具 JUnit 的使用
二、实验内容
实验任务 1 ：
请按以下操作步骤完成一个基本的 JUnit 测试实例。
以下是在IntelliJ IDEA环境下使用JUnit对Calculator类进行单元测试的详细步骤：
步骤1：创建Java项目
1. 打开IntelliJ IDEA → 新建项目 → 选择"Java" → 设置项目名称和路径 → 创建
步骤2：创建Calculator类
public class Calculator {
// 加法
public int add(int a, int b) {
return a + b;
}
// 减法
public int subtract(int a, int b) {
return a - b;
}
// 乘法
public int multiply(int a, int b) {
return a * b;
}
// 除法
public double divide(int a, int b) {
if(b == 0) throw new ArithmeticException("Cannot divide by zero");
return (double) a / b;
}
}
步骤3：添加JUnit依赖
1. 右键项目 → Open Module Settings
2. 选择"Libraries" → "+" → From Maven
3. 输入org.junit.jupiter:junit-jupiter-api:5.8.2 → 确定
4. 重复添加：
- org.junit.jupiter:junit-jupiter-engine:5.8.2
- org.junit.jupiter:junit-jupiter-params:5.8.2
步骤4：创建测试类
1. 在src/test/java目录右键 → New → Java Class → 命名为CalculatorTest
2. 添加测试类注解：
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculatorTest {
private Calculator calculator;
@BeforeEach
void setUp() {
calculator = new Calculator();
}
@Test
void testAdd() {
assertEquals(5, calculator.add(2, 3));
assertEquals(-1, calculator.add(2, -3));
}
@Test
void testSubtract() {
assertEquals(1, calculator.subtract(4, 3));
assertEquals(7, calculator.subtract(10, 3));
}
@Test
void testMultiply() {
assertEquals(6, calculator.multiply(2, 3));
assertEquals(-6, calculator.multiply(2, -3));
}
@Test
void testDivide() {
assertEquals(2.0, calculator.divide(6, 3));
assertEquals(3.333, calculator.divide(10, 3), 0.001);
}
@Test
void testDivideByZero() {
assertThrows(ArithmeticException.class, () -> calculator.divide(5, 0));
}
}
步骤5：运行测试
1. 点击测试类左侧的绿色箭头图标 ▶️
2. 选择"Run 'CalculatorTest'"
3. 查看结果：
- 绿色进度条：所有测试通过
- 红色进度条：存在失败的测试
步骤6：查看测试覆盖率（可选）
1. 右键测试类 → Run 'CalculatorTest' with Coverage
2. 查看覆盖率报告，确认是否覆盖所有代码分支
覆盖测试类所有分支 main是空函数不在测试中
以下是使用JUnit 5进行参数化测试的详细操作步骤：
步骤1：创建参数化测试方法
在CalculatorTest类中添加以下代码：
java
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
class CalculatorTest {
// ... 其他已有代码 ...
// 参数化加法测试（使用CSV数据）
@ParameterizedTest(name = "[{index}] {0} + {1} = {2}") // 定义测试名称模板
@CsvSource({
"2, 3, 5", // 正常情况
"-5, 5, 0", // 负数加法
"0, 0, 0", // 零值测试
"2147483647, 1, -2147483648" // 整数溢出边界
})
void parameterizedAddTest(int a, int b, int expected) {
assertEquals(expected, calculator.add(a, b));
}
// 参数化除法测试（使用CSV带浮点）
@ParameterizedTest
@CsvSource({
"6, 3, 2.0",
"10, 3, 3.333",
"1, 2, 0.5"
})
void parameterizedDivideTest(int a, int b, double expected) {
assertEquals(expected, calculator.divide(a, b), 0.001);
}
// 参数化异常测试（使用ValueSource）
@ParameterizedTest
@ValueSource(ints = {0, -0, 100}) // 测试多个除数为零的情况
void parameterizedDivideByZeroTest(int divisor) {
assertThrows(ArithmeticException.class, () -> calculator.divide(10, divisor));
}
}
步骤3：数据源类型详解
1. @CsvSource
- 使用CSV格式直接嵌入测试数据
- 适用场景：需要多参数组合的测试
- 语法示例：
java
@CsvSource({
"参数1a, 参数2a, 预期结果a",
"参数1b, 参数2b, 预期结果b"
})
2. @ValueSource
- 提供单个参数的简单值
- 适用场景：单一参数测试
- 支持类型：基本类型、String、Class
java
@ValueSource(ints = {1, 2, 3})
3. @MethodSource
- 通过方法提供复杂参数
- 在测试类中添加静态方法：
java
static Stream<Arguments> provideMultiplyData() {
return Stream.of(
Arguments.of(2, 3, 6),
Arguments.of(-4, 5, -20),
Arguments.of(0, 100, 0)
);
}
@ParameterizedTest
@MethodSource("provideMultiplyData")
void parameterizedMultiplyTest(int a, int b, int expected) {
assertEquals(expected, calculator.multiply(a, b));
}
步骤4：运行参数化测试
1. 在测试类中：
- 点击类名旁的绿色箭头 ▶️ → 运行所有测试
- 点击单个参数化测试方法旁的箭头 → 运行单个测试
2. 查看结果时：
- 每个参数组合会显示为独立测试项
- 测试名称会显示参数值（通过name属性自定义）
步骤5：验证测试报告
执行后会显示详细结果：
✓ parameterizedAddTest(int, int, int)[1] 2 + 3 = 5
✓ parameterizedAddTest(int, int, int)[2] -5 + 5 = 0
✓ parameterizedAddTest(int, int, int)[3] 0 + 0 = 0
✓ parameterizedAddTest(int, int, int)[4] 2147483647 + 1 = -2147483648
参数化测试注意事项
1. 浮点数精度处理：
java
assertEquals(3.333, calculator.divide(10, 3), 0.001); // 第三个参数是允许的误差范围
2. 异常测试特殊处理：
java
@CsvSource({"5, 0", "10, 0"})
void testDivideByZero(int a, int b) {
assertThrows(ArithmeticException.class, () -> calculator.divide(a, b));
}
实验任务 2 ：编写程序判断闰年，设计测试⽤例并⽤Junit进⾏测试。
实验步骤 ：
1.创建 Java 项目
2.编写判断闰年程序 ：创建一个名为 LeapYear 的类，编写判断闰年的方法。闰年的判断规则为：能被 4 整除但不能被 100 整除，或者能被 400 整除。
3.添加 JUnit 依赖 ：按照实验任务 1 的步骤 3 添加 JUnit 依赖。
4.创建测试类 ：在 src/test/java 目录下创建测试类 LeapYearTest。
package org.example;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class LeapYearTest {
private LeapYear leapYear;
@BeforeEach
void setUp() {
leapYear = new LeapYear();
}
@Test
void testNormalLeapYears() {
assertTrue(leapYear.isLeapYear(2020));
assertTrue(leapYear.isLeapYear(1996));
}
@Test
void testNonLeapYears() {
assertFalse(leapYear.isLeapYear(2021));
assertFalse(leapYear.isLeapYear(1900));
}
@Test
void testLeapYearBoundaries() {
assertTrue(leapYear.isLeapYear(2000));
assertFalse(leapYear.isLeapYear(1900));
assertTrue(leapYear.isLeapYear(1600));
}
@Test
void testInvalidYear() {
assertThrows(IllegalArgumentException.class, () -> leapYear.isLeapYear(0));
assertThrows(IllegalArgumentException.class, () -> leapYear.isLeapYear(-100));
}
}
- 编写测试用例 ：使用 JUnit 编写测试用例，测试正常年份、闰年边界情况等。
- 运行测试 ：运行测试类，查看测试结果。
- 查看测试覆盖率 ：可选择查看测试覆盖率，确认是否覆盖所有代码分支。
覆盖所有代码分支
实验任务3：编写程序判断非三角形，等腰三角形，等边三角形，直角三角形，钝角三角形，锐角三角形，设计测试用例并用JUnit进行测试。
实验步骤 ：
1.创建 Java 项目 ：按照实验任务 1 的步骤 1 创建 Java 项目。
2.编写判断三角形类型程序 ：创建一个名为 Triangle 的类，编写判断三角形类型的方法。根据三角形的边长判断其为非三角形、等腰三角形、等边三角形、直角三角形、钝角三角形或锐角三角形。
3.添加 JUnit 依赖 ：按照实验任务 1 的步骤 3 添加 JUnit 依赖。
4.创建测试类 ：在 src/test/java 目录下创建测试类 TriangleTest。
package org.example;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class TriangleTest {
private Triangle triangle;
@BeforeEach
void setUp() {
triangle = new Triangle();
}
@Test
void test不是三角形() {
assertEquals(Triangle.TriangleType.非三角形, triangle.determineTriangleType(1, 2, 3));
assertEquals(Triangle.TriangleType.非三角形, triangle.determineTriangleType(1, 1, 2));
}
@Test
void test等边三角形() {
assertEquals(Triangle.TriangleType.等边三角形, triangle.determineTriangleType(3, 3, 3));
assertEquals(Triangle.TriangleType.等边三角形, triangle.determineTriangleType(5, 5, 5));
}
@Test
void test等腰三角形() {
assertEquals(Triangle.TriangleType.等腰三角形, triangle.determineTriangleType(3, 3, 4));
assertEquals(Triangle.TriangleType.等腰三角形, triangle.determineTriangleType(5, 6, 5));
}
@Test
void test直角三角形() {
assertEquals(Triangle.TriangleType.直角三角形, triangle.determineTriangleType(3, 4, 5));
assertEquals(Triangle.TriangleType.直角三角形, triangle.determineTriangleType(5, 12, 13));
}
@Test
void test钝角三角形() {
assertEquals(Triangle.TriangleType.钝角三角形, triangle.determineTriangleType(2, 2, 3));
assertEquals(Triangle.TriangleType.钝角三角形, triangle.determineTriangleType(7, 8, 10));
}
@Test
void test锐角三角形() {
assertEquals(Triangle.TriangleType.锐角三角形, triangle.determineTriangleType(4, 5, 6));
assertEquals(Triangle.TriangleType.锐角三角形, triangle.determineTriangleType(2, 3, 4));
}
@Test
void test边长非法() {
assertThrows(IllegalArgumentException.class, () -> triangle.determineTriangleType(0, 2, 3));
assertThrows(IllegalArgumentException.class, () -> triangle.determineTriangleType(-1, 2, 3));
}
}
- 编写测试用例 ：使用 JUnit 编写测试用例，测试各种三角形类型的判断情况。
- 运行测试 ：运行测试类，查看测试结果。
- 查看测试覆盖率 ：可选择查看测试覆盖率，确认是否覆盖所有代码分支。
覆盖所有方法 但没覆盖所有代码
浙公网安备 33010602011771号