测试覆盖率

什么是测试覆盖率

首先，我们该如何评审自己写的测试用例是否满足测试要求？是否存在漏洞与缺陷？

这就要引入一个测试覆盖率的概念了。

测试覆盖率

覆盖率是用来度量测试完整性的手段，是测试效果衡量的标准，是测试技术有效性的度量：

覆盖率 = （至少被执行一次的项目(item)数） / （项目的总数）

项目是指：语句、判定、分支、函数等等。

覆盖率按照测试方法一般可分为三大类：

• 白盒覆盖率：语句、判定、条件、路径等等；
• 灰盒覆盖率：接口相关；
• 黑盒覆盖率：功能、性能测试；

另外还包括面向对象覆盖率等。

注意，测试用例设计不能一味的追求覆盖率，因为测试成本随覆盖率的增加而增加，要在覆盖率和成本之间有所取舍。

白盒覆盖率

白盒覆盖率中使用的最常见的就是逻辑覆盖率（Logical Coverage），也称为代码覆盖率（Code Coverage）、或者称为结构化覆盖率（Structural Coverage）。

逻辑覆盖率包括：

• 语句覆盖；
• 判定覆盖；
• 条件覆盖；
• 判定条件覆盖；
• 条件组合覆盖；
• 路径覆盖；

语句覆盖

语句覆盖（Statement Coverage）的含义是，在测试时运行被测程序后，程序中被执行到的可执行语句的比率：

语句覆盖率 = （至少被执行一次的语句数量） / （可执行的语句总数）

现在我们祭出在测试覆盖率篇中都会使用的一张图。

这个一个函数的流程图，需要传入三个参数；有两个语句，每个语句中有两个判断条件；根据传入参数的不同，它有几种可能的执行过程：abd、abe等等。牢记这张图。

我们用Python代码实现这个函数：

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 or x > 1:
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=2, b=1, x=3)

上面的示例中，我们分别写了两个用例case1和case2。

那么它们的用例怎么设计呢？又怎么计算语句覆盖率呢？

在测试时，首先设计若干个测试用例，然后运行被测程序，使程序中的每个可执行语句至少执行一次。

首先来看case1，在函数foo中，因为每个语句都包含两个子条件，所有共有4个语句，当然，你也可以只根据大的语句来划分，那就是2个语句。

根据case1的传入参数a=2, b=0, x=3，它符合：

编号	条件取值	标记
1	A>1	T
2	B==0	T
3	A==2	T
4	X>3	F

在程序运行中，上面4种情况都会覆盖到，所以，根据上面的公式：

34=75%34=75%

被执行的语句是4条除以可执行的语句总数4条，它的覆盖率是100%。

而case2，根据传入参数a=2, b=1, x=3：

编号	条件取值	标记
1	A>1, B==0	T,F
2	A==2, X>1	T,F

因为and的关系，上面第一条语句不会执行。所以，它的覆盖率50%。

12=50%12=50%

需要注意的是，有时候语句覆盖率达到100%也会有缺陷发现不了，比如开发人员将第二个语句写成了

and

：

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 and x > 1:  # 偷偷将 or 替换为 and
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=2, b=1, x=3)

自己算覆盖率吧！

所以覆盖率只是我们度量的一个手段。

判定覆盖率

判定覆盖（Decision Coverage）也叫分支覆盖（Branch Coverage），它是指在测试时运行被测试程序后，程序中所有判定语句的取真分支和取假被执行到的比率：

判定覆盖率 = （判定结果被评价的次数） / （判定结果的总数）

一般的判定条件可能有这些：if、ifelse、ifelifelse等等。

这个怎么玩呢？把最开始的程序图拿过来（你想象它在这！）。

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 or x > 1:
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=1, b=0, x=1)

我们设计了两个用例，来判断取真取假的情况。

来看case1，参数是a=2, b=0, x=3：

编号	条件取值	标记
1	A>1, B==0	T
2	A==2, X>1	T

在来看case2，参数是a=1, b=0, x=1：

编号	条件取值	标记
1	A>1, B==0	F
2	A==2, X>1	F

case1走了两次真，case2走了两次假，我们认为这两个用例的判定覆盖率达到了100%：

44=100%44=100%

需要注意的是，有时候语句覆盖率达到100%也会有缺陷发现不了，比如开发人员将第二个条件语句的

X>1

写成了

X<1

它的执行情况是：

用例	编号	条件取值	标记
case1	1	A>1, B==0	T
case1	2	A==2, X>1	T
case2	3	A>1, B==0	F
case2	4	A==2, X<1	F

此时的判定覆盖率仍然为100%，但是程序已经存在问题了。

条件覆盖率

条件覆盖（Condition Coverage）的含义时，在测试时运行被测程序后，所有的判断语句中每个条件的可能取值（真和假）出现过的比率：

条件覆盖率 = （条件操作数值至少被评价一次的数量） / （条件操作数的总数）

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 or x > 1:
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=1, b=0, x=1)
case3 = foo(a=2, b=1, x=1)

这个又该怎么玩呢？

我们在设计用例时，要使每个判断中的每个条件的可能值都要满足一次，这么说，上面的程序有4个语句，每个语句都有两种情况，所以，共有八种情况：

条件	取真	取假	标记
A>1	T	F	T,F
B==0	T	F	T,F
A==2	T	F	T,F
X>1	T	F	T,F

设计测试用例（看着那个图！）：

测试用例	参数：A B X	执行路径	覆盖条件
case1	203	ace	T,T,T,T
case2	101	abd	F,T,F,F
case3	211	abe	T,F,T,F

case1执行了四个真，case2执行了三个假，漏掉一个假，所以，我们又设计了case3来补上这个假，最终它们的条件覆盖率是：

88=100%88=100%

八种情况都覆盖了。

没完！覆盖了条件的测试用例不一定覆盖了分支：

测试用例	参数：A B X	执行路径	覆盖条件
case1	103	abe	F,T,F,T
case2	211	abe	T,FT,F

八种条件都走完了，但是用例少覆盖了分支acd。

判定条件覆盖率

判定条件覆盖率（Decision Condition Coverage）也叫分支条件覆盖率（Branch Condition Coverage）。所谓判定条件覆盖就是设计足够的测试用例，使得判断中每个条件的所有可能取值至少执行一次，同时每个判断本身的所有可能判断结果至少执行一次：

判定条件覆盖率 = （条件操作数值或判定结果至少被评价一次的数量） / （条件操作数值 + 判定结果总数）

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 or x > 1:
        x = x + 1
case1 = foo(a=2, b=1, x=3)
case2 = foo(a=0, b=0, x=1)

我们先单独算出来case1的条件覆盖率和判定覆盖率。

先来看条件的：

条件	取真	取假	标记
A>1	T	F	T,F
B==0	T	F	T,F
A==2	T	F	T,F
X>1	T	F	T,F

因为是8个条件。所以结果是4/8，覆盖率也是50%。

再来看判定，参数是a=2, b=1, x=3：

编号	条件取值	标记
1	A>1, B==0	T,F
2	A==2,X>1	T,T

虽然4个条件得的结果是TFTT，但由于第一个条件是and，而结果是TF，所以，不执行，所以结果是2/4，覆盖率是50%。

那么判定条件覆盖率怎么算呢？

48+24=61248+24=612

在来个示例，看看

case2

的，参数是

a=0, b=0, x=1

。

先来看条件的：

编号	条件取值	标记
1	A>1, B==0	F,T
2	A==2,X>1	F,F

因为是8个条件（四个语句分别取真假）。所以结果是4/8，覆盖率也是50%。

再来看判定，参数是a=0, b=0, x=1：

条件	取真	取假	标记
A>1,B==0	T	F	F,T
A==2,X>1	T	F	F,F

4个语句得的结果是FTFF，所以结果是2/4，覆盖率是50%。

最后的判定条件覆盖率仍然是6/12。

48+24=61248+24=612

条件组合覆盖率

再说条件覆盖率之前先来看个示例：

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    if a == 2 or x > 1:
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=1, b=1, x=1)

上例中，两个用例的判定：

用例名	取值	标记
case1:203	A>1,B==0	T,T
case1:203	A==2,X>1	T,T
case2:111	A>1,B==0	F,T
case2:111	A==2,X>1	F,F

汇总一下，两个用例的判定都覆盖到了，所以是4/4。

而条件覆盖率：

用例名	取值	标记
case1:203	A>1,B==0	T,T
case1:203	A==2,X>1	T,T
case2:111	A>1,B==0	F,F
case2:111	A==2,X>1	F,F

8个条件都覆盖到了，所条件覆盖率是8/8，那么，它们的判定条件覆盖率是12/12：

44+88=121244+88=1212

也就是说，现在判定条件覆盖率是100%。

现在，开发把上面两个条件的and 和or条件互换了。那么用上面的两个case它们的判定条件覆盖率同样是100%。

def foo(a, b, x):
    if a > 1 or b == 0:
        x /= a
    if a == 2 and x > 1:
        x = x + 1
case1 = foo(a=2, b=0, x=3)
case2 = foo(a=1, b=1, x=1)

判定：

用例	取值	标记
case1:203	A>1,B==0	T,T
case1:203	A==2,X>1	T,T
case1:111	A>1,B==0	F,F
case2:111	A==2,X>1	F,F

两个用例的判定仍然是4/4。条件是8/8，那么判定条件覆盖率是12/12，最终的结果是100%。所以开发写错了代码，这两个用例仍然没有发现这类问题。

针对这类问题，就要使用条件组合覆盖率了。

条件组合覆盖（Multiple Condition Coverage）的基本思想是设计足够的测试用例，使每个判定中条件的各种可能的组合都至少出现一次：

条件组合覆盖率 = （条件组合至少被评价一次的数量） / （条件组合总数）

同样是上面的示例。

每个判断中所有的组合都要覆盖到。

组合编号	条件取值	标记
1	A>1,B==0	T,T
2	A>1,B!=0	T,F
3	A<=1,B==0	F,T
4	A<=1,B!=0	F,F
5	A==2,X>1	T,F
6	A==2,X<=1	T,F
7	A!=2,X>1	F,T
8	A!=2,X<=1	F,F

两个判定，每个判定中有两个条件，所有共有八种条件，所以，要想达到条件组合覆盖率100%的话，这八种情况都要覆盖到。

测试用例	参数：A B X	覆盖组合编号	所走路径	覆盖条件
case1	203	1，5	ace	TTTT
case2	211	2，6	abe	TFTF
case3	103	3，7	abe	FTFT
case4	111	4，8	abd	FFFF

PS：覆盖组合编号内容是上上表中的组合编号。

上例中的四个测试用例覆盖了所有的条件、分支。

所以，条件组合覆盖率是100%的话，那么，条件、判定、语句都会达到100%。

但从程序运行路径角度来看，仅覆盖了3条路径，遗漏掉了acd。

所以，目前为止，并没有一种覆盖率能保证测试覆盖率达到100%。

路径覆盖率

路径覆盖（Path Coverage）是指在测试时运行被测程序后， 程序中所有可能的路径被执行过的比率。

路径覆盖率 = （至少被执行到一次的路径数） / （总的路径数）

还是那个示例，还是那个图！

如果你看着图的话， 程序执行的路径有以下几条：

测试用例	参数：A B X	覆盖路径
case1	203	ace
case2	101	abd
case3	211	abe
case4	301	acd

所以，我们设计的测试用以，要把这些路径都要覆盖到。

看着采用路径覆盖率好使，但是仍然不是完美的。

如果开发将程序写错成了：

def foo(a, b, x):
    if a > 1 and b == 0:
        x /= a
    # if a == 2 or x > 1:  # 正确的
    if a == 2 and x >= 1:  # 开发写错后的
        x = x + 1

那么，在这个错误示例中，用上面的几个用例，仍然每个路径都能覆盖到，但是这个错误却不能发掘出来。

所以说，每种覆盖率都有自己的局限性，因此在测试中， 要把各种覆盖率组合起来对测试用例进行综合考量。

一般的，我们选择覆盖率优先级是：

• 语句；
• 判定；
• 条件；
• 条件组合；
• 路径；

在白盒这里的几种覆盖率，大致就是这些，我们来看其他的。

灰盒覆盖率

灰盒覆盖率这主要包括：

• 函数覆盖；
• 接口覆盖；

函数覆盖

函数覆盖（Function Coverage）是针对系统或者一个子系统测试，它表示在该测试中，有那些函数被测试到了。其被测到的频率有多大，这些函数在系统所有函数中的比例有多大，函数覆盖是一个比较容易自动化的技术：

函数覆盖 = （至少被执行一次的函数数量） / （系统中函数的总数）

假如有100个函数，在测试过程中，有90个函数（至少被执行了一次的函数）被测试到了， 所以它的覆盖率是90%。

也有很多测试工具提供了了函数覆盖，比如说TrueCoverage、PureCoverage等。

接口覆盖率

接口覆盖（Interface Coverage）也叫做入口点覆盖（Entry-Point Coverage），要求通过设计一定的用例使系统的每个接口被测试到：

接口覆盖率 = （至少被执行一次的接口数量） / （系统中接口的总数）

被测试的接口可能是对外提供访问的接口，也可能是内部接口。

接口可是是函数与函数之间，模块与模块之间，子系统与子系统之间的接口。

我们主要关注接口之间的数据交换、有没有逻辑依赖等等。

比如有两条测试用例去测试4个接口，那么覆盖到了其中的两个，那么它的接口覆盖率是2/4。

黑盒覆盖率

黑盒测试主要应用在系统测试阶段，那么在系统测试阶段，它的测试过程一般是这样的。

• 根据需求提取需求项；
• 根据需求项提取功能点；
• 根据功能点设计测试用例。

所以，在黑盒覆盖率这块，主要就是做功能覆盖率（Functional Coverage）。

而在功能覆盖率中最常见的是需求覆盖（Requirement Coverage），其含义是通过设计一定的测试用例，要求每个需求点都被测试到。

需求覆盖率 = （被验证到的需求数量） / （总的需求数量）

功能覆盖方面的自动化工具比较少。

当然，以上是针对系统测试阶段来划分的。

当然，单元测试阶段，也能进行黑盒测试。

比如，我们对一个函数进行测试。我们可以把函数当成一个黑匣子，我们关注入参和返回的两边数据即可，而不用特意关注函数内部的实现。

面向对象覆盖率

结构化覆盖率用来度量测试的完整性已经被大家所接受，但是这个技术在面向对象领域却遇到挑战，由于传统的结构化度量没有考虑面向对象的一些特性，如继承、封装、多态。

继承对覆盖率度量的影响

class Base(object):

    def foo(self): pass

    def bar(self): pass

class Derived(Base):

    def foo(self): pass

case1 = Derived().foo()
case2 = Derived().bar()

# 要考虑到面向对象的继承关系
case3 = Base().foo()
case4 = Base().bar()

上例中，如果我们的用例不仅要测试到派生类的两个方法，虽然它背后也调用了基类的方法，但要考虑到继承的概念，要让基类自己执行自己的方法。

基于状态的类的覆盖率特点

来举个栈的示例。

class Stack(object):
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        self.items.pop()

        p = Stack()
p.push('a')  # case1
p.pop()      # case2

现在，站在灰盒测试的角度来说，通过测试出栈和入栈的操作，已经达到了测试的效果了。

这就完了么？没有！因为我们没有考虑到栈的特点，比如，我们有没有考虑，如果栈为空，你做出栈操作，会不会抛出异常？

如果这是个有边界限制的栈，栈满了，你还能做入栈操作吗？

所以，我们要考虑到栈的各种情况。

根据这些状态，来针对性写用例。

最后，从测试方法来说，有白盒、黑盒、灰盒。

当然，在平日没有必要将彼此划分的很清楚，因为我们学习覆盖率的目的是用来度量测试完整性的手段，只是验证测试效果的一种衡量标准。

还是要根据项目、测试阶段、测试方法不同，来采用不同的测试覆盖率。