测试覆盖率

陌路散爱 提交于 2019-12-05 20:07:10

什么是测试覆盖率

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

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

测试覆盖率

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

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

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

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

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

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

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

白盒覆盖率

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

逻辑覆盖率包括:

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

语句覆盖

语句覆盖(Statement Coverage)的含义是,在测试时运行被测程序后,程序中被执行到的可执行语句的比率:

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

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

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

我们用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)

上面的示例中,我们分别写了两个用例case1case2

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

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

首先来看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),它是指在测试时运行被测试程序后,程序中所有判定语句的取真分支和取假被执行到的比率:

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

一般的判定条件可能有这些:ifif\elseif\elif\else等等。

这个怎么玩呢?把最开始的程序图拿过来(你想象它在这!)。

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%。

也有很多测试工具提供了了函数覆盖,比如说TrueCoveragePureCoverage等。

接口覆盖率

接口覆盖(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

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

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

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

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

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

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

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

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


软件测试基础 - 测试覆盖率

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!