当前位置：首页 > article >正文

《软件工程》第 12 章 - 软件测试

article 2025/6/1 15:29:51

软件测试是确保软件质量的关键环节，它通过执行程序来发现错误，验证软件是否满足需求。本章将依据目录，结合 Java 代码示例、可视化图表，深入讲解软件测试的概念、过程、方法及实践。

12.1 软件测试的概念

12.1.1 软件测试的任务

软件测试的主要任务是：

发现错误：通过执行程序，找出代码中的缺陷和逻辑错误。
验证功能：确保软件满足用户需求和规格说明。
评估质量：对软件的可靠性、性能等质量属性进行评估。

12.1.2 测试阶段的信息流程

测试阶段的信息流程：

展示测试过程中的信息流转。

12.1.3 测试用例及其设计

测试用例是为测试而设计的一组输入和预期输出，用于验证软件的特定功能。例如，测试一个简单的加法函数的测试用例：

public class Calculator {public int add(int a, int b) {return a + b;}
}// 对应的测试用例（使用JUnit框架）
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class CalculatorTest {@Testpublic void testAddPositiveNumbers() {Calculator calculator = new Calculator();int result = calculator.add(3, 5);assertEquals(8, result); // 预期结果为8}@Testpublic void testAddNegativeNumbers() {Calculator calculator = new Calculator();int result = calculator.add(-3, -5);assertEquals(-8, result); // 预期结果为-8}
}

12.1.4 软件测试的原则

软件测试应遵循以下原则：

尽早测试：测试应从软件开发的早期阶段开始，如需求分析和设计阶段。
全面测试：覆盖所有可能的输入和场景，包括边界条件和异常情况。
避免自测：开发人员应避免测试自己编写的代码，减少主观因素影响。
记录测试结果：详细记录测试过程和结果，便于追踪和分析。

12.2 软件测试的过程模型

软件测试的过程模型通常与软件开发过程模型对应，常见的有 V 模型、W 模型等。以 V 模型为例：

展示 V 模型中测试阶段与开发阶段的对应关系。

12.3 软件测试方法

12.3.1 白盒测试

白盒测试基于代码的内部结构和逻辑，主要技术包括：

语句覆盖：确保每个语句至少执行一次。
判定覆盖：确保每个判定的真假分支至少执行一次。
条件覆盖：确保每个判定中的每个条件的可能取值至少执行一次。

示例代码及测试用例：

public class ControlFlow {public boolean checkNumber(int num) {if (num > 10 && num % 2 == 0) {return true;} else {return false;}}
}// 白盒测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class ControlFlowTest {@Testpublic void testCheckNumberTrue() {ControlFlow cf = new ControlFlow();assertTrue(cf.checkNumber(12)); // 覆盖true分支}@Testpublic void testCheckNumberFalse1() {ControlFlow cf = new ControlFlow();assertFalse(cf.checkNumber(5)); // 覆盖false分支（num <= 10）}@Testpublic void testCheckNumberFalse2() {ControlFlow cf = new ControlFlow();assertFalse(cf.checkNumber(11)); // 覆盖false分支（num为奇数）}
}

12.3.2 黑盒测试

黑盒测试基于软件的外部功能和需求，不考虑内部实现。主要技术包括：

等价类划分：将输入域划分为若干等价类，从每个等价类中选取代表性值作为测试用例。
边界值分析：选择输入域的边界值作为测试用例，如最小值、最大值、刚好超过边界的值。
错误推测法：基于经验和直觉推测可能的错误，设计针对性的测试用例。

以三角形分类函数为例：

public class TriangleClassifier {public String classify(int a, int b, int c) {// 检查是否构成三角形if (a <= 0 || b <= 0 || c <= 0 || a + b <= c || a + c <= b || b + c <= a) {return "非三角形";}// 检查等边三角形if (a == b && b == c) {return "等边三角形";}// 检查等腰三角形if (a == b || a == c || b == c) {return "等腰三角形";}// 普通三角形return "普通三角形";}
}// 黑盒测试用例（等价类划分和边界值分析）
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class TriangleClassifierTest {@Testpublic void testEquilateralTriangle() {TriangleClassifier tc = new TriangleClassifier();assertEquals("等边三角形", tc.classify(3, 3, 3));}@Testpublic void testIsoscelesTriangle() {TriangleClassifier tc = new TriangleClassifier();assertEquals("等腰三角形", tc.classify(3, 3, 4));}@Testpublic void testScaleneTriangle() {TriangleClassifier tc = new TriangleClassifier();assertEquals("普通三角形", tc.classify(3, 4, 5));}@Testpublic void testNotTriangle() {TriangleClassifier tc = new TriangleClassifier();assertEquals("非三角形", tc.classify(1, 2, 3));}@Testpublic void testBoundaryValues() {TriangleClassifier tc = new TriangleClassifier();assertEquals("非三角形", tc.classify(0, 3, 4)); // 边界值0assertEquals("等腰三角形", tc.classify(2, 2, 4)); // 边界值a+b=c}
}

12.4 软件测试活动及实施策略

12.4.1 单元测试

单元测试是对软件中的最小可测试单元（如方法、类）进行测试。例如，测试一个栈类的基本操作：

import java.util.EmptyStackException;public class Stack {private int[] array;private int top;private int capacity;public Stack(int capacity) {this.capacity = capacity;this.array = new int[capacity];this.top = -1;}public void push(int item) {if (top == capacity - 1) {throw new StackOverflowError("栈已满");}array[++top] = item;}public int pop() {if (isEmpty()) {throw new EmptyStackException();}return array[top--];}public int peek() {if (isEmpty()) {throw new EmptyStackException();}return array[top];}public boolean isEmpty() {return top == -1;}
}// 单元测试用例
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class StackTest {private Stack stack;@BeforeEachpublic void setUp() {stack = new Stack(5);}@Testpublic void testPushAndPop() {stack.push(10);stack.push(20);assertEquals(20, stack.pop());assertEquals(10, stack.pop());}@Testpublic void testPeek() {stack.push(10);assertEquals(10, stack.peek());assertEquals(10, stack.peek()); // 多次peek不应改变栈}@Testpublic void testEmptyStack() {assertTrue(stack.isEmpty());assertThrows(EmptyStackException.class, () -> stack.pop());assertThrows(EmptyStackException.class, () -> stack.peek());}@Testpublic void testStackOverflow() {for (int i = 0; i < 5; i++) {stack.push(i);}assertThrows(StackOverflowError.class, () -> stack.push(5));}
}

12.4.2 集成测试

集成测试是将多个单元组合成更大的模块进行测试，验证模块间的交互。例如，测试一个简单的订单处理系统：

// 订单类
public class Order {private String orderId;private double totalAmount;private boolean paid;public Order(String orderId, double totalAmount) {this.orderId = orderId;this.totalAmount = totalAmount;this.paid = false;}public String getOrderId() {return orderId;}public double getTotalAmount() {return totalAmount;}public boolean isPaid() {return paid;}public void setPaid(boolean paid) {this.paid = paid;}
}// 支付服务接口
public interface PaymentService {boolean processPayment(double amount);
}// 订单处理服务
public class OrderService {private PaymentService paymentService;public OrderService(PaymentService paymentService) {this.paymentService = paymentService;}public boolean checkout(Order order) {if (order.isPaid()) {return false;}boolean paymentResult = paymentService.processPayment(order.getTotalAmount());if (paymentResult) {order.setPaid(true);return true;}return false;}
}// 集成测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;public class OrderServiceIntegrationTest {@Testpublic void testCheckoutSuccess() {// 创建模拟的支付服务PaymentService paymentService = mock(PaymentService.class);when(paymentService.processPayment(100.0)).thenReturn(true);// 创建订单服务并注入模拟的支付服务OrderService orderService = new OrderService(paymentService);Order order = new Order("ORD123", 100.0);// 执行测试boolean result = orderService.checkout(order);// 验证结果assertTrue(result);assertTrue(order.isPaid());verify(paymentService, times(1)).processPayment(100.0);}@Testpublic void testCheckoutFailure() {PaymentService paymentService = mock(PaymentService.class);when(paymentService.processPayment(100.0)).thenReturn(false);OrderService orderService = new OrderService(paymentService);Order order = new Order("ORD123", 100.0);boolean result = orderService.checkout(order);assertFalse(result);assertFalse(order.isPaid());verify(paymentService, times(1)).processPayment(100.0);}
}

12.4.3 确认测试

确认测试验证软件是否满足用户需求和规格说明，通常包括功能测试、性能测试等。例如，测试一个用户注册功能：

// 用户类
public class User {private String username;private String email;private String password;public User(String username, String email, String password) {this.username = username;this.email = email;this.password = password;}// Getters and setterspublic String getUsername() { return username; }public String getEmail() { return email; }public String getPassword() { return password; }
}// 用户服务接口
public interface UserService {boolean registerUser(User user);boolean isValidEmail(String email);
}// 用户服务实现
public class UserServiceImpl implements UserService {@Overridepublic boolean registerUser(User user) {// 验证邮箱格式if (!isValidEmail(user.getEmail())) {return false;}// 验证用户名和密码长度if (user.getUsername().length() < 3 || user.getPassword().length() < 6) {return false;}// 模拟保存用户到数据库System.out.println("用户注册成功: " + user.getUsername());return true;}@Overridepublic boolean isValidEmail(String email) {// 简单的邮箱格式验证return email.matches("^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$");}
}// 确认测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class UserServiceVerificationTest {@Testpublic void testRegisterUserSuccess() {UserService userService = new UserServiceImpl();User user = new User("john_doe", "john@example.com", "password123");assertTrue(userService.registerUser(user));}@Testpublic void testRegisterUserInvalidEmail() {UserService userService = new UserServiceImpl();User user = new User("john_doe", "invalid_email", "password123");assertFalse(userService.registerUser(user));}@Testpublic void testRegisterUserShortUsername() {UserService userService = new UserServiceImpl();User user = new User("jo", "john@example.com", "password123");assertFalse(userService.registerUser(user));}@Testpublic void testRegisterUserShortPassword() {UserService userService = new UserServiceImpl();User user = new User("john_doe", "john@example.com", "pass");assertFalse(userService.registerUser(user));}
}

12.4.4 系统测试

系统测试将软件作为一个整体进行测试，验证系统是否满足需求。例如，测试一个在线购物系统的完整流程：

// 商品类
public class Product {private String productId;private String name;private double price;private int stock;public Product(String productId, String name, double price, int stock) {this.productId = productId;this.name = name;this.price = price;this.stock = stock;}// Getters and setterspublic String getProductId() { return productId; }public String getName() { return name; }public double getPrice() { return price; }public int getStock() { return stock; }public void setStock(int stock) { this.stock = stock; }
}// 购物车类
public class ShoppingCart {private Map<Product, Integer> items = new HashMap<>();public void addItem(Product product, int quantity) {items.put(product, items.getOrDefault(product, 0) + quantity);}public void removeItem(Product product) {items.remove(product);}public double getTotalPrice() {double total = 0;for (Map.Entry<Product, Integer> entry : items.entrySet()) {total += entry.getKey().getPrice() * entry.getValue();}return total;}public Map<Product, Integer> getItems() {return items;}
}// 订单类
public class Order {private String orderId;private List<Product> products;private double totalAmount;private OrderStatus status;public Order(String orderId, List<Product> products, double totalAmount) {this.orderId = orderId;this.products = products;this.totalAmount = totalAmount;this.status = OrderStatus.PENDING;}// Getters and setterspublic String getOrderId() { return orderId; }public List<Product> getProducts() { return products; }public double getTotalAmount() { return totalAmount; }public OrderStatus getStatus() { return status; }public void setStatus(OrderStatus status) { this.status = status; }
}// 订单状态枚举
public enum OrderStatus {PENDING, PAID, SHIPPED, DELIVERED, CANCELLED
}// 系统测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class ShoppingSystemSystemTest {@Testpublic void testEndToEndShoppingFlow() {// 创建商品Product laptop = new Product("P001", "笔记本电脑", 5000.0, 10);Product mouse = new Product("P002", "鼠标", 50.0, 20);// 创建购物车ShoppingCart cart = new ShoppingCart();cart.addItem(laptop, 1);cart.addItem(mouse, 2);// 验证购物车总价assertEquals(5100.0, cart.getTotalPrice(), 0.001);// 创建订单String orderId = "ORD" + System.currentTimeMillis();Order order = new Order(orderId, cart.getItems().keySet().stream().collect(Collectors.toList()), cart.getTotalPrice());// 处理订单支付order.setStatus(OrderStatus.PAID);assertEquals(OrderStatus.PAID, order.getStatus());// 更新库存for (Map.Entry<Product, Integer> entry : cart.getItems().entrySet()) {entry.getKey().setStock(entry.getKey().getStock() - entry.getValue());}// 验证库存更新assertEquals(9, laptop.getStock());assertEquals(18, mouse.getStock());// 发货order.setStatus(OrderStatus.SHIPPED);assertEquals(OrderStatus.SHIPPED, order.getStatus());// 确认收货order.setStatus(OrderStatus.DELIVERED);assertEquals(OrderStatus.DELIVERED, order.getStatus());}
}

12.5 面向对象软件的测试

12.5.1 类的测试

类的测试关注类的属性、方法和状态。例如，测试一个银行账户类：

public class BankAccount {private String accountNumber;private double balance;private AccountStatus status;public BankAccount(String accountNumber, double initialBalance) {this.accountNumber = accountNumber;this.balance = initialBalance;this.status = AccountStatus.ACTIVE;}public void deposit(double amount) {if (amount <= 0) {throw new IllegalArgumentException("存款金额必须大于0");}if (status != AccountStatus.ACTIVE) {throw new IllegalStateException("账户状态异常，无法存款");}balance += amount;}public void withdraw(double amount) {if (amount <= 0) {throw new IllegalArgumentException("取款金额必须大于0");}if (status != AccountStatus.ACTIVE) {throw new IllegalStateException("账户状态异常，无法取款");}if (amount > balance) {throw new InsufficientFundsException("余额不足");}balance -= amount;}public void close() {if (balance != 0) {throw new IllegalStateException("账户余额不为0，无法关闭");}status = AccountStatus.CLOSED;}// Getterspublic String getAccountNumber() { return accountNumber; }public double getBalance() { return balance; }public AccountStatus getStatus() { return status; }
}// 账户状态枚举
public enum AccountStatus {ACTIVE, CLOSED, FROZEN
}// 自定义异常
public class InsufficientFundsException extends RuntimeException {public InsufficientFundsException(String message) {super(message);}
}// 类的测试用例
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class BankAccountTest {private BankAccount account;@BeforeEachpublic void setUp() {account = new BankAccount("123456", 1000.0);}@Testpublic void testInitialState() {assertEquals("123456", account.getAccountNumber());assertEquals(1000.0, account.getBalance(), 0.001);assertEquals(AccountStatus.ACTIVE, account.getStatus());}@Testpublic void testDeposit() {account.deposit(500.0);assertEquals(1500.0, account.getBalance(), 0.001);}@Testpublic void testDepositNegativeAmount() {assertThrows(IllegalArgumentException.class, () -> account.deposit(-100.0));}@Testpublic void testWithdraw() {account.withdraw(300.0);assertEquals(700.0, account.getBalance(), 0.001);}@Testpublic void testWithdrawInsufficientFunds() {assertThrows(InsufficientFundsException.class, () -> account.withdraw(1500.0));}@Testpublic void testCloseAccount() {account.withdraw(1000.0); // 清空余额account.close();assertEquals(AccountStatus.CLOSED, account.getStatus());}@Testpublic void testCloseAccountWithBalance() {assertThrows(IllegalStateException.class, () -> account.close());}
}

12.5.2 交互测试

交互测试验证对象之间的协作和交互。例如，测试一个订单处理系统中对象间的交互：

// 订单类
public class Order {private String orderId;private List<OrderItem> items;private OrderStatus status;public Order(String orderId, List<OrderItem> items) {this.orderId = orderId;this.items = items;this.status = OrderStatus.PENDING;}public void processPayment(PaymentService paymentService) {double totalAmount = calculateTotalAmount();boolean paymentResult = paymentService.processPayment(totalAmount);if (paymentResult) {this.status = OrderStatus.PAID;}}private double calculateTotalAmount() {double total = 0;for (OrderItem item : items) {total += item.getProduct().getPrice() * item.getQuantity();}return total;}// Getters and setterspublic String getOrderId() { return orderId; }public List<OrderItem> getItems() { return items; }public OrderStatus getStatus() { return status; }
}// 订单条目类
public class OrderItem {private Product product;private int quantity;public OrderItem(Product product, int quantity) {this.product = product;this.quantity = quantity;}// Getterspublic Product getProduct() { return product; }public int getQuantity() { return quantity; }
}// 商品类
public class Product {private String productId;private String name;private double price;public Product(String productId, String name, double price) {this.productId = productId;this.name = name;this.price = price;}// Getterspublic String getProductId() { return productId; }public String getName() { return name; }public double getPrice() { return price; }
}// 支付服务接口
public interface PaymentService {boolean processPayment(double amount);
}// 交互测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;public class OrderInteractionTest {@Testpublic void testOrderPaymentProcess() {// 创建模拟的支付服务PaymentService paymentService = mock(PaymentService.class);when(paymentService.processPayment(100.0)).thenReturn(true);// 创建商品和订单条目Product product = new Product("P001", "手机", 100.0);OrderItem item = new OrderItem(product, 1);// 创建订单Order order = new Order("ORD123", List.of(item));// 处理支付order.processPayment(paymentService);// 验证结果assertEquals(OrderStatus.PAID, order.getStatus());verify(paymentService, times(1)).processPayment(100.0);}@Testpublic void testOrderPaymentFailure() {PaymentService paymentService = mock(PaymentService.class);when(paymentService.processPayment(100.0)).thenReturn(false);Product product = new Product("P001", "手机", 100.0);OrderItem item = new OrderItem(product, 1);Order order = new Order("ORD123", List.of(item));order.processPayment(paymentService);assertEquals(OrderStatus.PENDING, order.getStatus());verify(paymentService, times(1)).processPayment(100.0);}
}

12.5.3 继承的测试

继承的测试关注子类与父类的关系，以及多态的正确性。例如，测试一个形状继承体系：

// 抽象形状类
public abstract class Shape {public abstract double calculateArea();public abstract double calculatePerimeter();
}// 矩形类
public class Rectangle extends Shape {private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}@Overridepublic double calculateArea() {return length * width;}@Overridepublic double calculatePerimeter() {return 2 * (length + width);}
}// 正方形类
public class Square extends Rectangle {public Square(double side) {super(side, side);}
}// 圆形类
public class Circle extends Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double calculateArea() {return Math.PI * radius * radius;}@Overridepublic double calculatePerimeter() {return 2 * Math.PI * radius;}
}// 继承测试用例
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;public class ShapeInheritanceTest {@Testpublic void testRectangleArea() {Rectangle rectangle = new Rectangle(5.0, 3.0);assertEquals(15.0, rectangle.calculateArea(), 0.001);assertEquals(16.0, rectangle.calculatePerimeter(), 0.001);}@Testpublic void testSquareArea() {Square square = new Square(4.0);assertEquals(16.0, square.calculateArea(), 0.001);assertEquals(16.0, square.calculatePerimeter(), 0.001);}@Testpublic void testCircleArea() {Circle circle = new Circle(2.0);assertEquals(Math.PI * 4.0, circle.calculateArea(), 0.001);assertEquals(2 * Math.PI * 2.0, circle.calculatePerimeter(), 0.001);}@Testpublic void testPolymorphism() {Shape rectangle = new Rectangle(5.0, 3.0);Shape square = new Square(4.0);Shape circle = new Circle(2.0);assertEquals(15.0, rectangle.calculateArea(), 0.001);assertEquals(16.0, square.calculateArea(), 0.001);assertEquals(Math.PI * 4.0, circle.calculateArea(), 0.001);}
}

12.6小结

软件测试是软件开发过程中不可或缺的环节，它贯穿于整个软件生命周期。通过本章的学习，我们了解了软件测试的概念、过程模型、测试方法以及面向对象软件的测试技术。合理运用各种测试方法和技术，能够有效发现软件中的缺陷，提高软件质量，确保软件满足用户需求。在实际项目中，应根据项目特点和需求，选择合适的测试策略和方法，制定全面的测试计划，以保证软件的可靠性和稳定性。