feie9454/software-test-maintaining
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: initialize repository with gitignore

Browse Source
This commit is contained in:
feie9454
2026-04-13 07:16:39 +08:00
commit d3c18e8912
81 changed files with 4429 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hw3/app/src/main/java/triangle/App.java
+50
View File
@@ -0,0 +1,50 @@
package triangle;
public class App {
public enum TriangleType {
EQUILATERAL, // 等边三角形
ISOSCELES, // 等腰三角形
SCALENE, // 一般三角形
NOT_A_TRIANGLE // 非三角形
}
public static TriangleType classify(int a, int b, int c) {
// 检查边长是否为正整数
if (a <= 0 || b <= 0 || c <= 0) {
return TriangleType.NOT_A_TRIANGLE;
}
// 检查三角不等式（任意两边之和大于第三边）
// 使用 long 防止整数溢出
if ((long) a + b <= c || (long) a + c <= b || (long) b + c <= a) {
return TriangleType.NOT_A_TRIANGLE;
}
// 判断三角形类型
if (a == b && b == c) {
return TriangleType.EQUILATERAL;
} else if (a == b || b == c || a == c) {
return TriangleType.ISOSCELES;
} else {
return TriangleType.SCALENE;
}
}
public static void main(String[] args) {
if (args.length != 3) {
System.out.println("用法: java triangle.App <边1> <边2> <边3>");
return;
}
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = Integer.parseInt(args[2]);
TriangleType result = classify(a, b, c);
switch (result) {
case EQUILATERAL -> System.out.println("等边三角形");
case ISOSCELES -> System.out.println("等腰三角形");
case SCALENE -> System.out.println("一般三角形");
case NOT_A_TRIANGLE -> System.out.println("非三角形");
}
}
}
hw3/app/src/test/java/triangle/AppTest.java
+249
View File
@@ -0,0 +1,249 @@
package triangle;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import static org.junit.jupiter.api.Assertions.*;
import triangle.App.TriangleType;
class AppTest {
// ========================================================================
// 控制流图分析
// ========================================================================
//
// classify(int a, int b, int c) 的判定节点:
//
// D1: a <= 0 || b <= 0 || c <= 0
// 条件: c1(a<=0), c2(b<=0), c3(c<=0)
//
// D2: (long)a+b <= c || (long)a+c <= b || (long)b+c <= a
// 条件: c4(a+b<=c), c5(a+c<=b), c6(b+c<=a)
//
// D3: a == b && b == c
// 条件: c7(a==b), c8(b==c)
//
// D4: a == b || b == c || a == c
// 条件: c9(a==b), c10(b==c), c11(a==c)
//
// 环形复杂度 V(G) = 5（5个判定出口路径）
//
// ========================================================================
// ====================================================================
// (2) 语句覆盖 — 每条语句至少执行一次
// ====================================================================
//
// 需覆盖所有 5 个 return 语句，最少 5 个测试用例:
//
// | TC | 输入 (a,b,c) | 覆盖语句 | 预期结果 |
// |-----|-------------|-------------------|----------------|
// | SC1 | (-1, 5, 5) | D1=T→return | NOT_A_TRIANGLE |
// | SC2 | (1, 2, 10) | D1=F,D2=T→return | NOT_A_TRIANGLE |
// | SC3 | (5, 5, 5) | D1=F,D2=F,D3=T→return | EQUILATERAL |
// | SC4 | (5, 5, 3) | D1=F,D2=F,D3=F,D4=T→return | ISOSCELES |
// | SC5 | (3, 4, 5) | D1=F,D2=F,D3=F,D4=F→return | SCALENE |
@Nested
@DisplayName("(2) 语句覆盖")
class StatementCoverage {
@Test
@DisplayName("SC1: 边<=0 → NOT_A_TRIANGLE (覆盖D1真分支return)")
void sc1_negativeSide() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(-1, 5, 5));
}
@Test
@DisplayName("SC2: 不满足三角不等式 → NOT_A_TRIANGLE (覆盖D2真分支return)")
void sc2_inequalityViolation() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(1, 2, 10));
}
@Test
@DisplayName("SC3: 等边三角形 → EQUILATERAL (覆盖D3真分支return)")
void sc3_equilateral() {
assertEquals(TriangleType.EQUILATERAL, App.classify(5, 5, 5));
}
@Test
@DisplayName("SC4: 等腰三角形 → ISOSCELES (覆盖D4真分支return)")
void sc4_isosceles() {
assertEquals(TriangleType.ISOSCELES, App.classify(5, 5, 3));
}
@Test
@DisplayName("SC5: 一般三角形 → SCALENE (覆盖D4假分支return)")
void sc5_scalene() {
assertEquals(TriangleType.SCALENE, App.classify(3, 4, 5));
}
}
// ====================================================================
// (3) 判定-条件覆盖
// ====================================================================
//
// 要求: 每个判定取 T/F，每个条件取 T/F，至少各一次。
//
// 条件清单:
// D1: c1(a<=0) c2(b<=0) c3(c<=0)
// D2: c4(a+b<=c) c5(a+c<=b) c6(b+c<=a)
// D3: c7(a==b) c8(b==c)
// D4: c9(a==b) c10(b==c) c11(a==c)
//
// | TC | 输入 | D1 | c1 c2 c3 | D2 | c4 c5 c6 | D3 | c7 c8 | D4 | c9 c10 c11 | 结果 |
// |------|------------|-----|----------|-----|----------|-----|-------|-----|------------|----------------|
// | DC1 | (-1, 5, 5) | T | T F F | - | - | - | - | - | - | NOT_A_TRIANGLE |
// | DC2 | (5, -1, 5) | T | F T F | - | - | - | - | - | - | NOT_A_TRIANGLE |
// | DC3 | (5, 5, -1) | T | F F T | - | - | - | - | - | - | NOT_A_TRIANGLE |
// | DC4 | (1, 2, 10) | F | F F F | T | T F F | - | - | - | - | NOT_A_TRIANGLE |
// | DC5 | (1, 10, 2) | F | F F F | T | F T F | - | - | - | - | NOT_A_TRIANGLE |
// | DC6 | (10, 1, 2) | F | F F F | T | F F T | - | - | - | - | NOT_A_TRIANGLE |
// | DC7 | (5, 5, 5) | F | F F F | F | F F F | T | T T | - | - | EQUILATERAL |
// | DC8 | (5, 5, 3) | F | F F F | F | F F F | F | T F | T | T F F | ISOSCELES |
// | DC9 | (3, 5, 5) | F | F F F | F | F F F | F | F T | T | F T F | ISOSCELES |
// | DC10 | (5, 3, 5) | F | F F F | F | F F F | F | F F | T | F F T | ISOSCELES |
// | DC11 | (3, 4, 5) | F | F F F | F | F F F | F | F F | F | F F F | SCALENE |
//
// 覆盖验证:
// c1: T(DC1) F(DC2~11) ✓ c2: T(DC2) F(DC1,DC3~11) ✓ c3: T(DC3) F(DC1,DC2,DC4~11) ✓
// c4: T(DC4) F(DC5~11) ✓ c5: T(DC5) F(DC4,DC6~11) ✓ c6: T(DC6) F(DC4,DC5,DC7~11) ✓
// c7: T(DC7,DC8) F(DC9~11) ✓ c8: T(DC7,DC9) F(DC8,DC10,DC11) ✓
// c9: T(DC8) F(DC9~11) ✓ c10: T(DC9) F(DC8,DC10,DC11) ✓ c11: T(DC10) F(DC8,DC9,DC11) ✓
// D1: T(DC1~3) F(DC4~11) D2: T(DC4~6) F(DC7~11) D3: T(DC7) F(DC8~11) D4: T(DC8~10) F(DC11) ✓
@Nested
@DisplayName("(3) 判定-条件覆盖")
class DecisionConditionCoverage {
@Test
@DisplayName("DC1: a<=0=T → D1=T → NOT_A_TRIANGLE")
void dc1_aNegative() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(-1, 5, 5));
}
@Test
@DisplayName("DC2: b<=0=T → D1=T → NOT_A_TRIANGLE")
void dc2_bNegative() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(5, -1, 5));
}
@Test
@DisplayName("DC3: c<=0=T → D1=T → NOT_A_TRIANGLE")
void dc3_cNegative() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(5, 5, -1));
}
@Test
@DisplayName("DC4: a+b<=c=T → D2=T → NOT_A_TRIANGLE")
void dc4_sumABLeC() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(1, 2, 10));
}
@Test
@DisplayName("DC5: a+c<=b=T → D2=T → NOT_A_TRIANGLE")
void dc5_sumACLeB() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(1, 10, 2));
}
@Test
@DisplayName("DC6: b+c<=a=T → D2=T → NOT_A_TRIANGLE")
void dc6_sumBCLeA() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(10, 1, 2));
}
@Test
@DisplayName("DC7: a==b=T, b==c=T → D3=T → EQUILATERAL")
void dc7_equilateral() {
assertEquals(TriangleType.EQUILATERAL, App.classify(5, 5, 5));
}
@Test
@DisplayName("DC8: a==b=T, b==c=F → D3=F; a==b=T → D4=T → ISOSCELES")
void dc8_isoscelesAB() {
assertEquals(TriangleType.ISOSCELES, App.classify(5, 5, 3));
}
@Test
@DisplayName("DC9: a==b=F, b==c=T → D3=F; b==c=T → D4=T → ISOSCELES")
void dc9_isoscelesBC() {
assertEquals(TriangleType.ISOSCELES, App.classify(3, 5, 5));
}
@Test
@DisplayName("DC10: a==b=F, b==c=F → D3=F; a==c=T → D4=T → ISOSCELES")
void dc10_isoscelesAC() {
assertEquals(TriangleType.ISOSCELES, App.classify(5, 3, 5));
}
@Test
@DisplayName("DC11: 所有条件F → D3=F, D4=F → SCALENE")
void dc11_scalene() {
assertEquals(TriangleType.SCALENE, App.classify(3, 4, 5));
}
}
// ====================================================================
// (4) 基本路径覆盖
// ====================================================================
//
// 控制流图 (简化判定节点):
// N1(Start) → N2(D1) →T→ N3(return NOT_A_TRIANGLE) → N11(End)
// →F→ N4(D2) →T→ N5(return NOT_A_TRIANGLE) → N11
// →F→ N6(D3) →T→ N7(return EQUILATERAL) → N11
// →F→ N8(D4) →T→ N9(return ISOSCELES) → N11
// →F→ N10(return SCALENE) → N11
//
// 节点数 N=11, 边数 E=14
// 环形复杂度 V(G) = E - N + 2 = 14 - 11 + 2 = 5
//
// 5 条独立基本路径:
// Path1: N1→N2(T)→N3→N11 (边<=0, 非三角形)
// Path2: N1→N2(F)→N4(T)→N5→N11 (三角不等式不满足, 非三角形)
// Path3: N1→N2(F)→N4(F)→N6(T)→N7→N11 (等边三角形)
// Path4: N1→N2(F)→N4(F)→N6(F)→N8(T)→N9→N11 (等腰三角形)
// Path5: N1→N2(F)→N4(F)→N6(F)→N8(F)→N10→N11 (一般三角形)
//
// | TC | 路径 | 输入 (a,b,c) | 预期结果 |
// |------|--------|-------------|----------------|
// | BP1 | Path1 | (0, 5, 5) | NOT_A_TRIANGLE |
// | BP2 | Path2 | (1, 2, 4) | NOT_A_TRIANGLE |
// | BP3 | Path3 | (6, 6, 6) | EQUILATERAL |
// | BP4 | Path4 | (3, 3, 5) | ISOSCELES |
// | BP5 | Path5 | (3, 4, 6) | SCALENE |
@Nested
@DisplayName("(4) 基本路径覆盖 (V(G)=5)")
class BasicPathCoverage {
@Test
@DisplayName("BP1/Path1: N1→N2(T)→N3→End — 边<=0")
void bp1_path1_nonPositive() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(0, 5, 5));
}
@Test
@DisplayName("BP2/Path2: N1→N2(F)→N4(T)→N5→End — 三角不等式不满足")
void bp2_path2_inequalityFail() {
assertEquals(TriangleType.NOT_A_TRIANGLE, App.classify(1, 2, 4));
}
@Test
@DisplayName("BP3/Path3: N1→N2(F)→N4(F)→N6(T)→N7→End — 等边")
void bp3_path3_equilateral() {
assertEquals(TriangleType.EQUILATERAL, App.classify(6, 6, 6));
}
@Test
@DisplayName("BP4/Path4: N1→N2(F)→N4(F)→N6(F)→N8(T)→N9→End — 等腰")
void bp4_path4_isosceles() {
assertEquals(TriangleType.ISOSCELES, App.classify(3, 3, 5));
}
@Test
@DisplayName("BP5/Path5: N1→N2(F)→N4(F)→N6(F)→N8(F)→N10→End — 一般")
void bp5_path5_scalene() {
assertEquals(TriangleType.SCALENE, App.classify(3, 4, 6));
}
}
}