【软件工程】黑盒测试——因果图测试方法

,

黑盒测试——因果图测试方法


图：封面

开发语言及实现平台或实验环境

在 Windows 7 或 Windows 10 操作系统上，使用 C，C++，C#或 Java 语言 及对应的开发环境(IDE)

实验目的

  1. 认识黑盒测试方法中因果图测试方法原理
  2. 掌握黑盒测试方法中因果图测试方法过程

实验要求

  1. 要求学生能够理解因果图测试方法的相关概念、方法和过程。
  2. 具体为每一组，每组二——五人，根据实验题目编写出对应的 c 语言或 c++语言程序，组间相互交换程序，按黑盒测试的方法进行测试。

实验原理

对编写的实验内容，采用基于因果图测试方法进行黑盒测试。

实验材料

  1. 三角形问题
    问题描述:三角形问题接受三个整数，a、b 和 c 作为输入，用作三角
    形的边。程序的输出是由这三条边确定的三角形类型:等边三角形、等腰 三角形、不等边三角形或非三角形。
    作为输入:三角形的三条边必须满足如下条件: C1:1<=a<=100
    C2:1<=b<=100
    C3:1<=c<=100
    C4:a<b+c C5:b<a+c C6:c<a+b

实验步骤

  1. 预习相关课堂和实验内容，了解测试对象。
  2. 编写实验材料源代码。
  3. 在调试过程中，如果需要，就建立一个或多个桩模块，并建立一个驱动
    模块。
  4. 设计测试用例。
  5. 测试。
  6. 填写试验报告。

实验代码

三角形问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package procs;

        import java.util.InputMismatchException;
        import java.util.Scanner;

public class TriangleProc {

    public int sideA = 0;
    public int sideB = 0;
    public int sideC = 0;

    public TriangleProc() {

    }

    /**
     * 函数：验证三角形边的长度范围
     *
     * @param side
     * @return
     */
    public boolean verifyLengthRange(int side) {
        if ((side >= 1) && (side <= 100)) {
            return true;
        } else {
            System.out.println(String.format("边长 %1d 不满足大于等于1且小于等于 100", side));
            System.out.println("=========请重新输入=========");
            return false;
        }

    }

    /**
     * 函数：验证三角形两边之和大于第三边
     *
     * @param triangleProc
     * @return
     */
    public boolean verifyFormPrinciple(TriangleProc triangleProc) {

        if ((triangleProc.sideA + triangleProc.sideB <= triangleProc.sideC)
                || (triangleProc.sideA + triangleProc.sideC <= triangleProc.sideB)
                || (triangleProc.sideB + triangleProc.sideC <= triangleProc.sideA)) {
            System.out.println(String.format("边长组合为 %1d %2d %3d不满足两边之和大于第三边，是非三角形",
                    triangleProc.sideA, triangleProc.sideB, triangleProc.sideC));
            System.out.println("=========请重新输入=========");
            return false;
        } else {
            System.out.println("边长组合满足两边之和大于第三边");
            return true;
        }
    }


    public String judgeTriangleType(TriangleProc triangleProc) {
        if (triangleProc.sideA == triangleProc.sideB || triangleProc.sideA == triangleProc.sideC
                || triangleProc.sideB == triangleProc.sideC) {
            if (triangleProc.sideA == triangleProc.sideB && triangleProc.sideB == triangleProc.sideC) {
                String triangleType = "等边三角形";
                return triangleType;
            } else {
                String triangleType = "等腰三角形";
                return triangleType;
            }
        } else {
            String triangleType = "非等边三角形";
            return triangleType;
        }
    }

    public void inputEdge(Scanner scanner, TriangleProc triangleProc) {
        int tempSideA = 0;
        int tempSideB = 0;
        int tempSideC = 0;

//        System.out.println("Welcome to triangle judge program!!!d");
        System.out.println("Please input the side A");

        if (scanner.hasNext()) {
            tempSideA = scanner.nextInt();
            triangleProc.sideA = tempSideA;
            System.out.println(String.format("Edge A is %1d. Please input side B", tempSideA));
            tempSideB = scanner.nextInt();
            triangleProc.sideB = tempSideB;
            System.out.println(String.format("Edge B is %1d. Please input side C", tempSideB));
            tempSideC = scanner.nextInt();
            triangleProc.sideC = tempSideC;
            System.out.println(String.format("Edge C is %1d. The input is finished\n\n", tempSideC));

        }

        boolean stopFlag = false;

        while (!stopFlag) {
            if (verifyLengthRange(triangleProc.sideA) && verifyLengthRange(triangleProc.sideB)
                    && verifyLengthRange(triangleProc.sideC)) {
                if (verifyFormPrinciple(triangleProc)) {
                    stopFlag = true;
                    String triangleType = judgeTriangleType(triangleProc);
                    System.out.println(String.format("你输入的三角形类型为：%1s", triangleType));
                    System.out.println("========The End========");
                } else {
                    inputEdge(scanner, triangleProc);
                }

            } else {
                // 边长不满足两个条件，重新输入
                inputEdge(scanner, triangleProc);
            }
        }
    }


    /**
     * 主函数，同时也是测试函数
     *
     * @param args
     */
    public static void main(String[] args) {
        TriangleProc triangleProc = new TriangleProc();
        Scanner scanner = new Scanner(System.in);
        triangleProc.inputEdge(scanner, triangleProc);

    }

}

测试用例设计

三角形问题：测试用例设计

  1. 分析（输入输出数据以及其逻辑关系）
    因：
    C1: 1<=a<=100
    C2: 1<=b<=100
    C3: 1<=c<=100
    C4: a<b+c
    C5: b<a+c
    C6: c<a+b
    C7: a=b
    C8: a=c
    C9: b=c
    果：
    R1：等边三角形
    R2：等腰 三角形
    R3：不等边三角形
    R4：非三角形
    R5：不可能

  2. 关联（不同组合间的关联、约束或限制条件，形成因果图）

    中间条件： M1: 满足边长要求 M2: 构成三角形 M3: 满足全部输入要求 M4: 任意边长度相等 M5: 存在一条边边长相等 M6: 任意边边长都相等 M7: 边长不构成三角形

3.转换（因果图转换为决策表并简化）

条件 1 2 3 4 5 6 7 8 9 10 11 12 13 14
C1 F T T T T T T T T T T T T T
C2 - F T T T T T T T T T T T T
C3 - - F T T T T T T T T T T T
C4 - - - F T T T T T T T T T T
C5 - - - - F T T T T T T T T T
C6 - - - - - F T T T T T T T T
C7 - - - - - - T F F T T F T F
C8 - - - - - - F T F T F T T F
C9 - - - - - - F F T F T T T F
R1 1
R2 1 1 1
R3 1
R4 1 1 1 1 1 1
R5 1 1 1

因：
C1: 1<=a<=100
C2: 1<=b<=100
C3: 1<=c<=100
C4: a<b+c
C5: b<a+c
C6: c<a+b
C7: a=b
C8: a=c
C9: b=c
果：
R1：等边三角形
R2：等腰 三角形
R3：不等边三角形
R4：非三角形
R5：不可能
R6：输入错误（// 忘记加了）

4.输出（从决策表生成测试用例）

用例ID a b c 预期输出
1 0 2 3 非三角形
2 2 0 3 非三角形
3 2 3 0 非三角形
4 1 0 0 非三角形
5 0 1 0 非三角形
6 0 0 1 非三角形
7 3 3 2 等腰三角形
8 3 2 3 等腰三角形
9 2 3 3 等腰三角形
10 ? ? ? 不可能
11 ? ? ? 不可能
12 ? ? ? 不可能
13 3 3 3 等腰三角形
14 2 3 4 非等腰三角形

【测试代码及结果分析】

三角形问题：测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package exps;

import procs.TriangleProc;

public class TriangleTesting_fourth {

    public void checkShape(int sideA, int sideB, int sideC) {
        TriangleProc triangleProc = new TriangleProc();

        triangleProc.sideA = sideA;
        triangleProc.sideB = sideB;
        triangleProc.sideC = sideC;

        triangleProc.verifyLengthRange(triangleProc.sideA);
        triangleProc.verifyLengthRange(triangleProc.sideB);
        triangleProc.verifyLengthRange(triangleProc.sideC);

        triangleProc.verifyFormPrinciple(triangleProc);

        System.out.println("三角形类型为：" + triangleProc.judgeTriangleType(triangleProc));
    }

    public static void main(String[] args) {

        TriangleTesting_fourth triangleTesting_fourth = new TriangleTesting_fourth();

        triangleTesting_fourth.checkShape(0, 2, 3);
        triangleTesting_fourth.checkShape(2, 0, 3);
        triangleTesting_fourth.checkShape(2, 3, 0);
        triangleTesting_fourth.checkShape(1, 0, 0);
        triangleTesting_fourth.checkShape(0, 1, 0);
        triangleTesting_fourth.checkShape(0, 0 ,1);
        triangleTesting_fourth.checkShape(3, 3, 2);
        triangleTesting_fourth.checkShape(3, 2, 3);
        triangleTesting_fourth.checkShape(2, 3, 3);
        System.out.println("=====不可能=====");
        System.out.println("=====不可能=====");
        System.out.println("=====不可能=====");
        triangleTesting_fourth.checkShape(3, 3, 3);
        triangleTesting_fourth.checkShape(2, 3, 4);


    }

}

三角形问题：测试结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
边长 0 不满足大于等于1且小于等于 100
边长组合为 0  2   3不满足两边之和大于第三边，是非三角形
三角形类型为：非等边三角形
边长 0 不满足大于等于1且小于等于 100
边长组合为 2  0   3不满足两边之和大于第三边，是非三角形
三角形类型为：非等边三角形
边长 0 不满足大于等于1且小于等于 100
边长组合为 2  3   0不满足两边之和大于第三边，是非三角形
三角形类型为：非等边三角形
边长 0 不满足大于等于1且小于等于 100
边长 0 不满足大于等于1且小于等于 100
边长组合为 1  0   0不满足两边之和大于第三边，是非三角形
三角形类型为：等腰三角形
边长 0 不满足大于等于1且小于等于 100
边长 0 不满足大于等于1且小于等于 100
边长组合为 0  1   0不满足两边之和大于第三边，是非三角形
三角形类型为：等腰三角形
边长 0 不满足大于等于1且小于等于 100
边长 0 不满足大于等于1且小于等于 100
边长组合为 0  0   1不满足两边之和大于第三边，是非三角形
三角形类型为：等腰三角形
边长组合满足两边之和大于第三边
三角形类型为：等腰三角形
边长组合满足两边之和大于第三边
三角形类型为：等腰三角形
边长组合满足两边之和大于第三边
三角形类型为：等腰三角形
=====不可能=====
=====不可能=====
=====不可能=====
边长组合满足两边之和大于第三边
三角形类型为：等边三角形
边长组合满足两边之和大于第三边
三角形类型为：非等边三角形

满足实验预期

实验总结

基于因果图的黑盒测试方法的一般测试步骤

  1. 分析
    分析输入输出数据（因和果）
    分析输入输出数据的关系
  2. 关联
    不同组合间的关联、约束或限制条件，形成因果图
  3. 转换
    将因果图转换为决策表并进行简化
  4. 输出
    从决策表生成测试用例

因果图测试适用的范围

通常适用于要产生大量决策的情况，或者输入变量之间存在重要逻辑关系。

1.决策表测试法适用于具有以下特征的应用程序

  • 程序的 if then else 逻辑突出
  • 输入变量之间存在逻辑关系
  • 计算过程涉及输入变量子集的处理
  • 输入与输出之间存在因果关系
  • 圈复杂度较高的应用

2.适用于使用决策表设计测试用例的条件

  • 规格说明以决策表形式给出，或较容易转换为决策表
  • 条件的排列顺序不会也不应影响执行的操作
  • 规则的排列顺序不会也不应影响执行的操作
  • 当某一规则的条件已经满足，并确定要执行的操作后，不必检验别的规则
  • 如果某一规则的条件要执行多个操作，这些操作的执行顺序无关紧要