黑盒测试用例设计

Posted 2021-10-22 我在路上-T

 

测试用例

测试用例的定义

测试用例是为了特定的目的而设计的一组由测试输入、执行条件、预期结果的案例（文档）

测试用例的构成要素

用例编号—用例的唯一标识

例如：QQMail_login_001

用例标题—用例的简要描述（什么情况下做什么事，有什么结果）

测试项目—用例 所属项目 范畴

用例级别—用例重要程度影响（P1：高优先级，P2：一般优先级，P3：低优先级）

预置条件—用例执行的前提（环境、数据）

测试输入—测试用例 数据输入

执行步骤—执行用例的步骤

预期结果 = 数据输入 + 预期结果 —— 应该得到的结果

• 测试用例例子

   

   

   

   

黑盒测试用例设计方法

什么是黑盒测试

通过输入、输出测试系统功能的方法

黑盒测试用例设计方法

等价类

等价类概念：在所有的测试数据中，具有某种共同特征的数据子集。

 

等价类划分规则：

 

等价类设计测试用例步骤

1.分析需求，确定输入数据类型

2.使用规则划分有效和无效等价类

3.设计用例，覆盖有效等价类——一条用例尽可能多的覆盖有效等价类

4.设计用例，覆盖无效等价类——一条用例只能覆盖一个无效等价类

例子：固定电话号码测试

 

 

 

 

 

 

---

边界值

• 大量的错误发生在输入或者输出范围的边界值上，而不是在输入范围的内部。

边界值法定义：选取正好等于、刚刚好大于或刚刚好小于边界值作为测试数据。

闭区间：[0,100]

上点：0,100 ；离点：-1,101；内点：50

半闭半开区间：（0,100]

上点：0,100 ；离点：1,101；内点：50

开区间：（0,100）

上点：0,100 ；离点：1,99；内点：50

 

边界值法设计测试用例

1.分析需求，确定输入数据类型

2.使用规则划分有效和无效等价类

3.确认上点、离点和内点

4.设计用例，覆盖有效等价类——一条用例尽可能多的覆盖有效等价类

5.设计用例，覆盖无效等价类——一条用例只能覆盖一个无效等价类

• 边界值设计测试用例的案例：固定电话号码测试

 

 

 

判定表法

• 使用等价类方法时对于输入域及输入域存在关联时无法覆盖

判定表设计用例步骤：

1.分析需求，定义条件桩与动作桩

2.设计优化判定表（全组合），得到条件项

 

 

3.根据条件项，依次填写动作项

4.简化判定表

5.抽取用例（每条规则就是一个用例）

• 案例

 

因果图法

• 与判定表的关系：判定表：先全组合画判定表再分析；因果图法：先分析再画判定表

 因果图设计用例的步骤

1.考虑所有输入/输出条件的相互制约关系以及组合关系

2.考虑输入条件之间的依赖关系

3.再根据分析的关系来转化为判定表的规则

 

 

状态迁移图法

• 状态迁移图：首先要找出所有的状态，然后再分析各个状态之间的转换条件和转换路径。然后从其状态迁移路径覆盖角度来设计测试用例。（多用于协议测试）

状态迁移图法测试步骤：

1.明确状态节点

2.绘制状态迁移图

3.绘制状态迁移树

4.抽取路径设计用例

状态迁移图法案例

 

场景法

软件几乎都是用事件触发来控制流程的，事件触发时的情景便形成了场景，而同一事件不同的触发顺序和处理结果就形成事件流。

• 重要概念：基本流、备选流、（异常流）

场景法步骤：

1.分析需求，确定基本流和备选流

2.根据基本流和备选流生成场景

3.根据场景生成用例

 

 

测试理论 - 白盒测试 - 测试用例设计

1. 概述
   1. 白盒测试 用例设计
      1. 本质上更加偏向于 单元测试
2. 背景
   1. 黑盒看了, 再看看白盒

1. 分类

1. 概述
   1. 简单分类
   2. 跟 黑盒 的差不多
2. 分类
   1. 通过性测试
   2. 失败性测试
3. 执行
   1. 顺序
      1. 通过性测试
      2. 失败性测试

2. 与 黑盒测试 的区别

1. 概述
   1. 与 黑盒测试 比对
2. 区别
   1. 执行者
      1. 黑盒
         1. 通常是测试
      2. 白盒
         1. 单元测试, 通常应该是 开发 来写
   2. 思路
      1. 黑盒
         1. 视角
            1. 用户
         2. 验证内容
            1. 输入与输出
            2. 使用逻辑
      2. 白盒
         1. 视角
            1. 开发
         2. 验证内容
            1. 更加偏向于 代码逻辑

3. 白盒用例设计

1. 概述
   1. 白盒用例设计
2. 基本思路
   1. 尽量遍历每一行代码
   2. 如果一条用例不够, 就用两条
      1. 条数尽量少
   3. 主要思考的语句块(java)
      1. if
      2. for / while
      3. switch
      4. try catch finally
3. 其他
   1. 黑盒测试的那些设计思路, 还是用得上的
      1. 等价类
      2. 边界值
      3. 判定表
      4. 正交表
4. 例子
   1. 概述
      1. 用来解释说明各种覆盖

   2. 例子1

      // 最好画个 流程图 吧, 我懒得画了
      // 点a
      if (a > 1 && b == 0) {
          // 不经过, 为 点b
          // 经过, 为 点c
          ...
      }
      if (a == 2 || x > 1) {
          // 不经过, 为 点d
          // 经过, 为 点e
          ...
      }

      1. 语句覆盖

5. 概述
   1. 执行所有语句
6. 思路
   1. 设计尽可能少的用例
   2. 执行所有的语句
7. 用例
   1. a = 2, b = 0, x = 2
      1. ace
8. 结果
   1. 测试了所有代码
9. 问题
   1. 但是 if 不成立时候的分支, 没有被执行
      1. 解决
         1. 分支覆盖

2. 分支覆盖

1. 概述
   1. 尝试遍历过 所有的分支
2. 思路
   1. 语句覆盖
      1. 每个分支, 至少被执行一次
3. 用例
   1. a = 3, b = 0, x = 1
      1. acd
   2. a = 2, b = 1, x = 2
      1. abe
4. 结果
   1. 语句全部覆盖
   2. 分支全部覆盖
5. 问题
   1. 有可能会有 判定条件 覆盖不到
      1. 比如这里的 第二组 数据
         1. 选择了 路线b
         2. 因为 a = 2, b 是否为 0 被跳过了
         3. 所以说, b != 0 这个 判定, 并没有被覆盖到
      2. 解决
         1. 条件覆盖

3. 条件覆盖

1. 概述
   1. 更加关注 具体的判定条件
2. 思路
   1. 条件覆盖
      1. if 里的条件, 都要验证到
3. 用例
   1. a = 1, b = 0, x = 3
      1. abe
   2. a = 2, b = 1, x = 1
      1. abd
4. 结果
   1. 语句没有完全覆盖
   2. 判定倒是完全覆盖了
5. 问题
   1. 需要 分支 和 条件 一起覆盖

4. 分支/条件覆盖

1. 概述
   1. 分支和条件都要兼顾
2. 思路
   1. 用尽量少的用例
      1. 覆盖所有分支
      2. 覆盖所有条件
3. 用例
   1. a = 2, b = 0, x = 4
      1. ace
   2. a = 1, b = 1, x = 1
      1. abd
   3. a = 2, b = 1, x = 1
      1. abd
4. 结果
   1. 语句完全覆盖
   2. 条件完全覆盖
5. 问题
   1. 还是会漏掉一些东西
      1. 比如 a = 1, b = 0 的场景, 就没有考虑
      2. 或者说, 是漏掉 某些判定的可能组合

5. 多重条件覆盖

1. 概述
   1. 一个 if 里, 是一个 判定组合
   2. 每个组合, 都会有一些可能的情况
2. 思路
   1. 第一个 if, 有这些组合
      1. a > 1, b = 0;
      2. a > 1, b != 0;
      3. a <= 1, b = 0;
      4. a <= 1, b != 0;
   2. 第一个 if, 有这些组合
      1. a = 2, x > 1
      2. a = 2, x <= 1
      3. a != 2, x > 1
      4. a != 2, x <= 1
   3. 需要用尽量少的用例, 把他们组合起来
      1. 1 - 5
      2. 2 - 6
      3. 3 - 7
      4. 4 - 8
3. 用例
   1. a = 2, b = 0, x = 4
   2. a = 2, b = 1, x = 1
   3. a = 1, b = 0, x = 2
   4. a = 1, b = 1, x = 1
4. 结果
   1. 覆盖了所有语句
   2. 覆盖了所有判定可能
   3. 覆盖了 判定组合 的所有可能
5. 问题
   1. 执行起来, 可能会比较多
      1. 当然, 白盒测试, 很多都是 自动化用例

ps

1. ref
   1. 软件测试的艺术
   2. 白盒测试及用例详解
2. 其他
   1. 编写 单元测试
   2. 使用 单元测试框架 来组织 单元测试
      1. testng
         1. 刚好有讲...
      2. junit
   3. 使用 代码覆盖率工具, 检查 单元测试 覆盖率
      1. jacoco