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

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. 语句覆盖

1. 概述

   1. 执行所有语句

2. 思路

   1. 设计尽可能少的用例
   2. 执行所有的语句

3. 用例

   1. a = 2, b = 0, x = 2
      1. ace

4. 结果

   1. 测试了所有代码

5. 问题

   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, 有这些组合
      5. a = 2, x > 1
      6. a = 2, x <= 1
      7. a != 2, x > 1
      8. 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