精华内容
下载资源
问答
  • 在中提到了代码覆盖率,我很久没有去书店了,不知道是不是出了新的版本,觉得书里面关于代码覆盖率方面的知识有些地方没有讲,在这里补充一下。先回顾一下如何创建一个C#工程WildChar(无所谓是类型库工程还是命令行...
  • Coverage Status是一个Visual Studio Code插件,可在状态栏中显示SimpleCov或LCOV格式的代码覆盖率。 要求 为了使用此扩展,您需要有可用的代码覆盖率数据。 该扩展支持用于Ruby项目的SimpleCov,以及用于所有其他...
  • 覆盖率

    千次阅读 2020-12-06 19:55:05
    覆盖率类型 覆盖率的两种指定形式:显式的: 直接通过SV来指定出的,如SVA,covergroup。隐式的: 在验证过程中,随"register move"就可以由simulator得到的,如代码覆盖率等。 覆盖率类型代码覆盖率—由仿真器...

    覆盖率类型

    覆盖率的两种指定形式:显式的: 直接通过SV来指定出的,如SVA,covergroup。隐式的: 在验证过程中,随"register move"就可以由simulator得到的,如代码覆盖率等。
    覆盖率类型:

    代码覆盖率:工具会自动搜集已经编写好的代码,常见的代码覆盖率如下:
    (1)行覆盖率(line coverage):记录程序的各行代码被执行的情况。
    (2)条件覆盖率(condition coverage):记录各个条件中的逻辑操作数被覆盖的情况。
    (3)跳转覆盖率(toggle coverage):记录单bit信号变量的值为0/1跳转情况,如从0到1,或者从1到0的跳转。
    (4)分支覆盖率(branch coverage):又称路径覆盖率(path coverage),指在if,case,for,forever,while等语句中各个分支的执行情况。

    状态机覆盖率(FSM coverage):用来记录状态机的各种状态被进入的次数以及状态之间的跳转情况。

    功能覆盖率:是一种用户定义的度量,主要是衡量设计所实现的各项功能,是否按预想的行为执行,即是否符合设计说明书的功能点要求,功能覆盖率主要有两种如下所示:
    (1)面向数据的覆盖率(Data-oriented Coverage)-对已进行的数据组合检查.我们可以通过编写覆盖组(coverage groups)、覆盖点(coverage points)和交叉覆盖(cross coverage)获得面向数据的覆盖率.
    (2)面向控制的覆盖率(Control-oriented Coverage)-检查行为序列(sequences of behaviors)是否已经发生.通过编写SVA来获得断言覆盖率(assertion coverage).

    覆盖组 covergroup

    通过覆盖组在特定的时刻采集某些感兴趣的变量covergroup 包含采样点(coverpoint),covergroup模块可以定义到某个class类中,也可以在interface中,或者在顶层的tb model中。每个采样点应该包括,采样时刻采样哪些信号预期采样信号的结果是什么。
    例子:以下covergroup 写在class里面,

    class transaction;
      transaction tr;
      mailbox mbc_in;
      covergroup covport;              //定义covergroup 采样组,没有定义采样时刻,可用sample()函数进行手动触发
        coverpoint tr.port;            //定义coverpoint  采样信号,这里没有设置采样信号的预期结果,意味着默认所有可能的信号值都会被采集下来。
      endgroup
      
      function new(mailbox mbx_in);
        covport=new();                //例化采样组,或者这样写, covport cfg=new(), 例化时给采样组起个名字cfg
        this.mbx_in=mbx_in;
      endfunction
    
      task main;
        forever begin
          tr=mbx_in.get;
          ifc.cb.port <= tr.port;
          ifc.cb.data <= tr.data;
          covport.sample();           //在某个事件中,定义采样动作,sample()函数,这个为非阻塞手动触发,调用task即可进行一次采样。
        end
      endtask
    enbclass
    
    event trans_ready;
    covergroup covport @(trans_ready);       //定义采样时刻,在trans_ready事件触发时,这个采样组会被一直阻塞住,或者@(posedge clk) 上升沿采样
      coverpoint ifc.cb.port;
    endgroup
    

    如果写在class外面,这需要把采集的信号通过传参传进去,

    covergroup covport(ref transaction tr);              
        coverpoint tr.port;          
      endgroup
    

    建立采样仓(bin),记录预期的采样值被捕捉的次数

    coverpoint可以指定一个感兴趣的采样信号,或者一个表达式等,并且给出该信号的预期采样值,通过建立采样仓放入预期值,就可以明确知道预期的值有没有被采样到,且被采样到多少次,如果预期值在确定的采样时刻上被采样到了,就可以表示该信号点的功能被覆盖到。
    另外,一个覆盖组(covergroup)能定义多个coverpoint,而coverpoint中可以自己定义多个采样仓(cover bin),或者不定义(表示该采样信号点所有可能的值都包含在采样仓内)

    covergroup covport;
      coverpoint tr.kind{            //采集的变量
        bins zero={0};               //建立的一个仓,仓名是zero,预期值是tr.kind==0
        bins lo={[1:3],5};           //建立的一个仓,仓名是low, 预期值是tr.kind==1:3 和 5
        bins hi[]={[8:$]};           //建议hi[8]....hi[f]等8个仓,预期值是hi[8]=8....hi[f]=15
        bins misc=default;           //建立一个仓,预期值是tr.kisd剩下可能的值
      }
    endgroup
    

    分配的仓的情况如下:

    bins_name  hits_num  at_least
    hi_8       0         1                   //bins_name表示仓的名称,hits_num表示该仓类可能的预期值,被采集到的次数,at_least表示,在该预期值理应被至少采集到一次  
    hi_9       5         1                   //coverpoint 定义了总共11个仓,有一个一次都没有被采集到,所以该coverpoint 的覆盖率是10/11
    hi_a       3         1 
    hi_b       4         1 
    hi_c       2         1 
    hi_d       2         1 
    hi_e       9         1 
    hi_f       4         1 
    
    lo         16        1
    misc       15        1
    zero        1        1
    

    添加采集条件 iff

    假设定义采集时刻是,每个clk上升沿触发,但是在rest复位期间,去采集就不是合理的,所以需要定义采样条件。有以下两种方法:

    covergroup covport iff(!bus_if.reset);    
      coverpoint port{
      ....
      }
      
    endgroup
    

    要么给covergroup 覆盖组整体定义采样条件,要么给每个coverpoint采样点单独定义一个采样条件,如下

    covergroup covport ;    
      coverpoint port iff(!bus_if.reset){
      ....
      }
    endgroup
    

    另外一种方法,如果是用sample()函数触发采样,那么如何给它设置采样条件?

    covergroup covport ;    
      coverpoint port{
      ....
      }
    endgroup
    
    initial begin
      covpor ck=new();
      #1ns;
      ck.stop();                     //暂停,等复位           
      bus_if,reset=1;
      #100ns bus_if.reset=0;
      ck.start();                    //开始
      ....
      ck.sample();
      ....
    end
    

    采集信号的翻转情况

    从场景A到场景B,某个信号预期要发生跳变,也可以使用coverpoint来采集这个信号跳变次数,并记录翻转率。

    covergroup covport;
      coverpoint point{                    //采样point信号,
        bins t1=(0=>1), (0=>2), (0=>3);    //采样仓为t1,信号跳变要么从0到1,要么是0到2,要么是0到3
      }
    endgroup
    

    通配符 wildcard

    使用wildcard可以采样到任意值,包括x和z,如下

    bit[2:0]  port;
    covergroup covport;
      coverpoint port{
        wildcard bins t1={3'b??0};
        wildcard bins t2={3'b??1};
      }
    endgroup
    

    忽略某些采集值ignore_bins,illegal_bins

    一个信号,预期的值会比较多,不关心的值少,要么将所有预期值一个一个写出来,要么将不关心的排出掉,剩下的所有值都是关心值。

    bit[2:0]  port;                                 //port值可能是0~5
    covergroup covport;
      coverpoint port{
        ignore_bins hi={[6,7]};                     //忽略掉6和7,剩下的就是要关心的      
      }
    endgroup
    

    如果预期某个值不能出现,使用illegal_bins,表示出现的该值,报错。

    bit[2:0]  port;                                 //port值可能是0~5
    covergroup covport;
      coverpoint port{
        illegal_bins hi={[6,7]};                     //采集到6和7,就报错  
      }
    endgroup
    

    交叉覆盖率cross,某个时刻,检测多个变量之间的组合

    在某个时刻,采集的两个信号可能会有一定的关联,要满足一定的关系,此时使用交叉覆盖率。

    class transaction;
      rand bit[3:0] kind;            //16种可能值
      rand bit[2:0] port;            //8种可能值
    endclass
    
    transaction tr;
    covergroup covport;
      kind: coverpoint tr.kind;        //这里kind和port是两个coverpoint,上面的例子都只有一个coverpoint ,就没有给名称, kind 有16种可能
      port: coverpoint tr.port;       //port 有8种可能
      cross kind, port;               //cross两个coverpoint ,表示两个coverpoint 采集到的信号是相关的,两个采集到信号组合起来看覆盖率,总共就是8*16种可能值
    endgroup
    

    排除掉部分可能值,交叉覆盖的可能值太多了,可能需要排除部分情况:binsofintersect:忽略某值

    covergroup covport;
       port: coverpoint tr.port{
         bins port[]={[0:$]};                 //port[0]=0 port[1]=1 port[2]=2....port[7]=7
      }          
      kind: coverpoint tr.kind{
        bins zero={0};
        bins lp={[1:3]};
        bins hi[]={[8:$]};                   //hi[8]=8,hi[9]=9....hi[16]=16
        bins misc=default;
      }
      cross kind, port{ 
        ignore_bins hi=binsof(port) intersect{7};    //在coverpoint port中 忽略port=7
        ignore_bins md=binsof(port) intersect{0} && binsof(kind) intersect{[9:11]}; //在coverpoint port中忽略 port=0且在coverpoint 中kind=9~11
      }            
    endgroup
    

    也可以指定感兴趣的组合:

    class transaction;
      rand bit a, b;    
    endclass
    
    transaction tr;
    covergroup covport;
      a: coverpoint tr.a{
        bins a0={0};
        bins a1={1};
        option.weigth=0;        //coverpoint a 不计算它的覆盖率
      }
      b: coverpoint tr.b{
        bins b0={0};
        bins b1={1};
        option.weigth=0;         //coverpoint b 不计算它的覆盖率
      }
      ab: cross a,b{
        bins a0b0=binsof(a.ao) && binsof(b.b0);       //coverpoint a 中的ao bins 且 coverpoint b 中的b0 bins,同时满足
        bins b1=binsof(b.b1);
      }
    endgroup
    
    展开全文
  • 代码覆盖率和测试覆盖率 测试覆盖率和代码覆盖率是衡量代码有效性的最流行方法。 尽管这些术语有时会互换使用,因为它们的基本原理相同。 但是它们并不像您想象的那样相似。 很多时候,我注意到测试团队和开发团队...

    代码覆盖率和测试覆盖率

    测试覆盖率和代码覆盖率是衡量代码有效性的最流行方法。 尽管这些术语有时会互换使用,因为它们的基本原理相同。 但是它们并不像您想象的那样相似。 很多时候,我注意到测试团队和开发团队对这两个术语的使用感到困惑。 这就是为什么我想到写一篇文章来详细讨论代码覆盖率和测试覆盖率之间的区别的原因。

    代码覆盖率与测试覆盖率:它们有何不同?

    代码覆盖率:指示通过用Selenium或任何其他测试自动化框架进行的手动测试和自动化测试,测试用例覆盖的代码百分比。 例如,如果您的源代码具有一个简单的if ... else循环,则如果您的测试代码将覆盖这两种情况(即if&else),则代码覆盖率将为100%。

    测试范围:包括测试作为功能需求规范,软件需求规范和其他必需文档的一部分而实现的功能。 例如,如果要对Web应用程序执行跨浏览器测试 ,以确保您的应用程序是否可以从其他浏览器很好地呈现? 您的测试范围将围绕验证了Web应用程序的浏览器兼容性的浏览器+操作系统组合的数量。

    了解了代码覆盖率和测试覆盖率之间的基本区别之后,让我们跳入有关代码覆盖率和测试覆盖率的更多详细信息。

    深入了解代码覆盖率

    开发人员在单元测试期间执行代码覆盖,以验证代码实现,从而几乎执行所有代码语句。 大多数代码覆盖率工具都使用静态工具,将监视执行的语句插入到代码中的必要位置。 尽管添加检测代码会导致整体应用程序大小和执行时间增加,但与通过执行检测代码生成的信息相比,开销却很小。 输出包括一个详细描述测试套件测试范围的报告。

    为什么要执行代码覆盖率?

    单元测试主要用于在单个单元级别上测试代码。 由于单元测试由开发人员自己编写,因此他对应该作为单元测试的一部分包含的测试具有更好的可见性。 单元测试有助于提高软件的整体质量,但是始终存在关于组成单元测试的测试数量的问题。 测试套件中是否有足够数量的测试方案? 我们应该添加更多测试吗? 代码覆盖率是所有这些问题的答案。

    随着产品开发的进行,新功能以及修复程序(针对测试过程中产生的错误)将添加到发布周期中。 这意味着测试代码可能还需要更改,以便通过开发过程中进行的软件更改来保持更新。 在项目开始时设定的测试标准必须与后续的发布周期保持一致,这一点很重要。 代码覆盖率可用于确保您的测试符合这些标准,并且质量最好的代码进入生产阶段。

    代码覆盖率更高; 出现未检测到的错误的机会越低。 在某些组织中,质量团队设置在将软件推向生产阶段之前需要实现的最小代码覆盖量。 这样做的主要原因是为了减少在产品开发的后期发现错误的可能性。

    如何执行代码覆盖率?

    代码覆盖范围有不同的级别,代码覆盖率的一些常见子类型为:

    • 分支机构覆盖范围–分支机构覆盖范围也称为决策覆盖范围,用于确保决策过程中使用的每个可能的分支都得以执行。 例如,如果您使用代码中的If…Ans条件语句或Do…While语句合并后备跨浏览器兼容性,作为覆盖范围的一部分; 您必须通过提供适当的输入以使跨浏览器兼容的网站来确保对所有分支(即If,Else,Do和While)进行测试。
    • 功能覆盖范围–功能覆盖范围可确保测试必要的功能(尤其是导出的功能/ API)。 这还应包括使用不同类型的输入参数测试功能,因为这也将测试功能中使用的逻辑。 一旦测试了代码中的所有功能,功能覆盖率将为100%。
    • 语句覆盖率–这是一种重要的代码覆盖率方法,其中必须以某种方式编写测试代码,即源代码中的每个可执行语句至少执行一次。 这也包括极端情况或边界情况。
    • 循环覆盖–这种方法是确保源中的每个循环至少执行一次。 可能会根据您在运行时获得的结果来执行某些循环,同样重要的是测试此类循环以使代码万无一失。

    为了检查代码覆盖率,使用了一种称为检测的方法。 工具可用于监视性能,插入跟踪信息以及诊断源代码中的任何类型的错误。 仪器种类繁多,取决于所使用的仪器方法,可能会有最小的性能(和时序)开销。

    仪器类型

    仪器分为三种主要类型

    • 代码检测-这里的源代码是在添加检测语句之后编译的。 编译应使用常规工具链完成,编译成功将导致生成检测装配。 例如,为了检查在代码中执行特定功能所花费的时间,可以在功能的“开始”和“结束”中添加检测语句。
    • 运行时检测–与代码检测方法相反,此处的信息是从运行时环境(即在执行代码时)收集的。
    • 中间代码检测–在这种检测中,通过向已编译的类文件中添加字节码来生成检测类。

    根据测试要求,您应该选择正确的代码覆盖率工具以及该工具支持的最佳检测方法。

    代码覆盖率工具

    有许多支持不同编程语言的代码覆盖工具,其中许多还可以兼用作QA工具。 许多工具可以与构建工具和项目管理工具集成在一起,从而使它们更加强大和有用。 选择开源代码覆盖率工具时,应检查该工具支持的功能以及该工具是否正在积极开发中。 基于这些因素,以下是一些流行的开源代码覆盖工具。

    1. Coverage.py –这是Python的代码覆盖工具。 顾名思义,它可以分析您的源代码并确定已执行代码的百分比。 它是用Python开发的。 它是免费的,您可以参考https://coverage.readthedocs.io/en/coverage-5.0.3/了解更多信息。
    2. Serenity BDD –支持Java和Groovy编程语言,Serenity BDD是一个流行的开源库,主要用于更快地编写出色的质量验收测试。 您可以使用故事和史诗进行测试,并为这些故事和史诗计算代码覆盖率。 因此,生成的测试报告实际上更具说明性和叙述性。 您可以将这些自动化测试映射回您的需求中。
      它可以与JUnit,Cucumber和JBehave一起使用。 Serenity BDD可以轻松地与Maven,Cradle,JIRA和Ant集成。 如果您使用Selenium WebDriver或Selenium Grid框架进行自动化测试,则选择Serenity BDD将具有巨大优势,因为它与Selenium兼容。 您可以参考https://www.thucydides.info/#/documentation了解更多信息。
    3. JaCoCo – JaCoco是Java的代码覆盖工具。 尽管还有其他选项,例如Cobertura和EMMA,但由于长时间没有更新,因此不推荐使用这些工具。 JaCoCo工具是Eclipse Foundation的一部分,它替代了Eclipse中的EMMA代码覆盖率工具。 除了积极开发JaCoCo之外,使用JaCoCo的另一个优势是可以与CI / CD和项目管理工具(例如Maven,Jenkins,Gradle等)无缝集成。请访问官方网站以获取更多信息。
    4. JCov – JCov是测试框架不可知代码覆盖工具。 它可以轻松地与Oracle的测试基础架构JavaTest和JTReg集成。 尽管尚未积极开发,但对即时检测和脱机检测的支持是使用JCov的主要优势。 请访问https://wiki.openjdk.java.net/display/CodeTools/jcov了解更多信息。
    5. PITest –大多数代码覆盖率工具都会检查代码的分支覆盖率,语句覆盖率,循环覆盖率等,并给出覆盖率结果。 尽管这些信息对于提高测试代码的质量很有用,但是测试并不能告诉您自动化测试在发现错误方面的表现如何。 这是变异测试非常有用的地方。
      PITest是一种非常流行的代码覆盖工具,用于Java和JVM的变异测试。 它通过修改您的测试代码来完成变异测试的工作,并且现在在此修改后的代码上执行单元测试。 如果使用此代码发现了错误,即PITest添加了额外的代码后,则单元测试是万无一失的。 否则,由于尚未发现问题,因此需要更改。 PITest易于使用,快速且正在积极开发中。 它还与流行的CI / CD工具集成在一起,使其更加有用。 有关更多信息,请访问http://pitest.org/

    深入了解测试覆盖率

    与代码覆盖率是白盒测试方法不同,测试覆盖率是黑盒测试方法。 以最大范围覆盖FRS(功能需求规范),SRS(软件需求规范),URS(用户需求规范)等中提到的需求的方式编写测试用例。由于测试是从这些文档中衍生的,因此自动化的机会很小/没有机会。

    如何执行测试覆盖率?

    与代码覆盖率一样,也可以通过不同类型的测试来评估测试覆盖率。 但是,应遵循哪种测试完全取决于您的业务主张。例如–在以用户为中心的Web应用程序中,可能会出现UI / UX测试比功能测试具有更高优先级的情况,而在其他类型的应用程序中(例如银行,金融); 可用性测试,安全性测试等可能更为重要。

    以下是一些测试覆盖率机制:

    • 单元测试–这种测试在单元级别/模块级别执行。 在单元级别遇到的错误可能与在集成阶段遇到的问题不同。
    • 功能测试–在功能测试中,将根据功能需求规范(FRS)中提到的要求对功能/功能进行测试。
    • 集成测试–由于软件是在系统级别进行测试的,因此也称为系统测试。 一旦集成了所有必需的模块,便会执行此类测试。
    • 验收测试–全部取决于验收测试的结果,是否将产品发布给最终消费者/客户。 在此,开发人员可以从Web应用程序的测试人员和SME获得绿色通道的批准,然后才将代码更改从暂存环境推送到生产环境

    要注意的另一个重要点是,测试覆盖范围的目的和含义可能会根据执行测试的级别而有所不同。 它还取决于执行黑盒测试的产品类型。 用于测试手机的测试覆盖率指标将不同于用于电子商务网站测试的指标。 一些分类如下:

    • 功能覆盖范围–在此情况下,以最大程度覆盖产品功能的方式开发测试用例。 例如,如果为测试人员分配了测试电话拨号程序应用程序的工作, 他应确保所拨打的号码长度正确。 如果测试是在印度完成的,则手机号码最多为10位数字; 否则它应该闪烁一个错误。 与此类似,必须根据产品团队设置的优先级对所有必需和可选功能进行测试。
    • 风险范围–每个产品/项目需求文档都有一节提到与项目相关的风险和缓解措施。 尽管某些风险(例如,业务动态的变化)超出了计划/开发/测试团队的范围,但在测试阶段仍需要解决一些风险。
      例如,在开发商业网站时,应该以非常快速的页面访问方式来设置服务器基础结构。 根据访问网站的位置(即国家,城市等),应选择最接近的服务器来加载网站。 否则,整个体验将受到阻碍。 测试团队还应该执行负载测试,其中当多个用户尝试同时访问该网站时即完成性能测试时,即网站上流量巨大的场景。 如果这些测试的结果不好,则可能会导致用户体验低于平均水平(这可能会带来巨大的风险)。
    • 需求范围–这里定义测试的方式是最大程度地覆盖各种需求规范文档中提到的产品需求。
      例如,如果您正在测试预安装的SMS应用程序,则需要确保正确设置默认语言,例如,如果手机在英语不是主要语言的国家/地区销售,例如中国; 默认的SMS语言应为中文,并适用于其他客户(例如印度); 默认语言应为英语。

    测试覆盖率工具

    在代码覆盖率的情况下,度量标准是通过测试用例/测试套件测试的代码的百分比。 因此,可以量化测试结果,即在100 LOC(代码行)中,代码覆盖率为80行。 这意味着代码覆盖率为80%。 由于执行测试以验证功能要求,因此无法量化测试覆盖率的结果。 您还可以提出可以在单个测试中测试多个需求的黑盒测试,例如,为了在简单的电子邮件登录页面中测试失败情况,您可以编写一个测试用例,输入不带@的电子邮件地址符号,然后尝试继续登录。 这将测试登录页面的功能,并检查用于验证电子邮件地址格式的逻辑是否按要求工作。

    尽管在少数情况下必须编写测试代码来达到测试覆盖率要求,但是在某些情况下,您可能仍需要使用一些流行的测试框架。 两种最受欢迎​​的测试框架是:

    • JUnit – JUnit是Java的单元测试框架。 它也可以用于UI测试。 它是开源的,并且在TDD(测试驱动开发)的开发中被认为很重要。 开发人员和测试人员使用JUnit编写和执行重复的测试。 这也使它成为回归测试的流行框架。 有关更多信息,请参阅https://junit.org/junit5/

    使用JUnit首先运行Selenium Automation测试脚本

    • PyUnit – PyUnit(也称为Python单元测试框架)是一种广泛用于单元测试的广泛使用的测试框架。 它是JUnit的Python端口,由遵循TDD方法的Python开发人员使用。 PyUnit支持测试用例,测试套件,测试装置等的开发。unittest模块是PyUnit框架的核心。 请参阅https://docs.python.org/2/library/unittest.html了解更多信息。

    使用PyUnit首先运行Selenium自动化测试脚本

    尽管开发人员/测试人员可以使用许多其他工具/测试框架来编写测试代码,但JUnit和PyUnit是各自编程语言中最受欢迎的测试框架。

    您应该遵循哪一个?

    衡量代码覆盖率和测试覆盖率的影响的基础完全不同。 代码覆盖率是通过测试期间覆盖的代码百分比来衡量的,而测试覆盖率是通过测试覆盖的功能来衡量的。

    百万美元的问题是“其中哪一项最适合您的项目”? 这个问题没有明确的答案,因为解决方案取决于项目的类型和复杂性。 在大多数情况下,使用测试覆盖率和代码覆盖率,因为它们在软件项目中同等重要。

    测试覆盖范围的优势

    • 一种测试软件功能并比较不同规范文档(需求,功能,产品,UI / UX等)结果的好方法
    • 由于作为覆盖范围一部分执行的测试实际上是黑盒,因此执行这些测试可能不需要太多的专业知识。

    取决于测试覆盖范围的缺点

    • 由于测试主要是黑盒测试,因此没有自动化范围。 测试结果的手动比较必须与预期的输出进行,因为这些测试是在“功能级别”而不是“代码级别”执行的。
    • 没有测量测试覆盖率的具体方法。 因此,覆盖范围的结果在很大程度上取决于正在执行测试的测试人员的领域能力,并且可能因一个测试人员而异。

    代码覆盖范围的优势

    • 提供测试代码的有效性以及如何提高覆盖率
    • 无论使用哪种工具(开源,高级),设置代码覆盖率工具都不会花费很多时间。
    • 通过捕获代码中的错误来帮助提高代码质量。

    代码覆盖范围的缺点

    • 大多数代码覆盖率工具仅限于单元测试。
    • 因此,工具使用的方法可能有所不同; 您可能无法将一种工具的代码覆盖率结果与另一种工具进行比较。
    • 搜索最适合的工具可能是一项艰巨的任务,因为在选择最适合您项目需求的工具之前,您需要比较并尝试这些工具的功能。
    • 提供很少支持不同编程语言(例如Java,Python,C等)的工具。因此,如果您的团队使用多种编程语言(用于测试代码开发),则可能需要多个工具。

    多少覆盖范围足够?

    测试次数更多; 产品的质量越好。 设计,开发和测试团队之间应该经常沟通,以便每个利益相关者都可以了解有关项目活动的详细信息。

    测试团队应花费大量时间来了解总体要求并确定测试活动的优先级。 为了跟踪进度,他们应该有一个清单,该清单应该定期更新(至少在每个发行版之后)。 测试团队还必须与质量保证(QA)团队保持频繁的沟通,这是很重要的,因为他们拥有要发布给客户/客户的产品/项目必须达到的目标(测试/代码)覆盖范围的详细信息。

    总而言之,没有专门的经验法则提到测试产品时需要达到的最小代码覆盖率或测试覆盖率百分比。

    如何确保最大的代码覆盖率和测试覆盖率?

    通过测试获得更好结果的一种方法是将自动化纳入测试计划。 不可能完全自动化整个测试过程,因此您必须制定一个计划。 该计划应突出显示必须手动和通过自动化执行的测试活动。

    覆盖率是一个有用的指标,但范围有限。 没有理想的方法可以衡量在测试上花费的精力。 众所周知的事实是100%的覆盖率只是一个神话。

    包含不同类型的测试(例如自动化测试,集成测试,手动测试,跨浏览器测试等)的整体方法将非常有用。 它可以帮助您在一个地方衡量不同测试和测试系统的有效性。

    不要针对100%的代码覆盖率

    您要记录的一件事是,永远不要以为100%的代码覆盖率都认为您的代码更改没有错误。 原因是100%的代码覆盖率表示您的自动化测试脚本覆盖了每一行代码。 但是,我们需要考虑错误的否定和错误的肯定,这可能会使我们脱离所添加代码的现实。 另外,您的Web应用程序中还会有一些未经测试的代码。 您需要仔细考虑未经测试的代码。 如果它是从旧版本中删除的,则可以将其删除;或者,如果它是来自缺少文档的最新修补程序,则对其进行测试。

    结论

    代码覆盖率是白盒方法,而测试覆盖率是黑盒测试方法。 根据项目的要求和范围,您应该选择测试覆盖率/代码覆盖率/测试覆盖率和代码覆盖率。 您应该确定测试活动的优先级,并为每个活动指定一个暂定期限。 不管使用哪种方法,重要的是要达到更高的覆盖率,因为这将表明代码和产品功能已得到很好的测试。 干杯!

    翻译自: https://www.javacodegeeks.com/2020/02/code-coverage-vs-test-coverage-which-is-better.html

    代码覆盖率和测试覆盖率

    展开全文
  • 代码覆盖率的含义

    2020-10-01 13:30:42
    在学习极客时间的测试52讲...绝大多数常见的代码覆盖率类型的定义。 这里我给你简单介绍一下最常用的三种代码覆盖率指标。 行覆盖率又称为语句覆盖率,指已经被执行到的语句占总可执行语句(不包含类似 C++ 的头.

    在学习极客时间的测试52讲中,了解到其实代码覆盖率的具体含义如下:

     

    简单来说,代码覆盖率是指,至少被执行了一次的条目数占整个条目数的百分比。
    如果“条目数”是语句,对应的就是代码行覆盖率;如果“条目数”是函数,对应的就是函
    数覆盖率;如果“条目数”是路径,那么对应的就是路径覆盖率。依此类推,你就可以得到
    绝大多数常见的代码覆盖率类型的定义。
    这里我给你简单介绍一下最常用的三种代码覆盖率指标。
    行覆盖率又称为语句覆盖率,指已经被执行到的语句占总可执行语句(不包含类似 C++
    的头文件声明、代码注释、空行等等)的百分比。这是最常用也是要求最低的覆盖率指
    标。实际项目中通常会结合判定覆盖率或者条件覆盖率一起使用。
    判定覆盖又称分支覆盖,用以度量程序中每一个判定的分支是否都被测试到了,即代码中
    每个判断的取真分支和取假分支是否各被覆盖至少各一次。比如,对于 if(a>0 &&
    b>0),就要求覆盖“a>0 && b>0”为 TURE 和 FALSE 各一次。
    条件覆盖是指,判定中的每个条件的可能取值至少满足一次,度量判定中的每个条件的结
    果 TRUE 和 FALSE 是否都被测试到了。比如,对于 if(a>0 && b>0),就要
    求“a>0”取 TRUE 和 FALSE 各一次,同时要求“b>0”取 TRUE 和 FALSE 各一次。
    代码覆盖率的价值 现在很多项目都在单元测试以及集成测试阶段统计代码覆盖率,但是我想说的是,统计代码
    覆盖率仅仅是手段,你必须透过现象看到事物的本质,才能从根本上保证软件整体的质量。
    统计代码覆盖率的根本目的是找出潜在的遗漏测试用例,并有针对性的进行补充,同时还可
    以识别出代码中那些由于需求变更等原因造成的不可达的废弃代码。
    通常我们希望代码覆盖率越高越好,代码覆盖率越高越能说明你的测试用例设计是充分且完
    备的,但你也会发现测试的成本会随着代码覆盖率的提高以类似指数级的方式迅速增加。
    如果想达到 70% 的代码覆盖率,你可能只需要 30 分钟的时间成本。但如果你想把代码覆
    盖率提高到 90%,那么为了这额外的 20%,你可能花的时间就远不止 30 分钟了。更进一
    步,你如果想达到 100% 的代码覆盖率,可想而知你花费的代价就会更大了。
    那么,为什么代码覆盖率的提高,需要付出越来越大的代价呢?因为在后期,你需要大量的
    桩代码、Mock 代码和全局变量的配合来控制执行路径。
    所以,在软件企业中,只有单元测试阶段对代码覆盖率有较高的要求。因为从技术实现上
    讲,单元测试可以最大化地利用打桩技术来提高覆盖率。而你如果想在集成测试或者是
    GUI 测试阶段将代码覆盖率提高到一定量级,那你所要付出的代价是巨大的,而且在很多
    情况下根本就实现不了。
    代码覆盖率的局限性
    我先来问你一个问题,如果你通过努力,已经把某个函数的 MC/DC 代码覆盖率(MC/DC
    覆盖率是最高标准的代码覆盖率指标,除了直接关系人生命安全的软件以外,很少会有项目
    会有严格的 MC/DC 覆盖率要求)做到了 100%,软件质量是否就真的高枕无忧、万无一
    失了呢?
    很不幸,即使你所设计的测试用例已经达到 100% 的代码覆盖率,软件产品的质量也做不
    到万无一失。其根本原因在于代码覆盖率的计算是基于现有代码的,并不能发现那些“未考
    虑某些输入”以及“未处理某些情况”形成的缺陷。
    我给你举个极端的例子,如果一个被测函数里面只有一行代码,只要这个函数被调用过了,
    那么衡量这一行代码质量的所有覆盖率指标都会是 100%,但是这个函数是否真正实现了应
    该需要实现的功能呢? 显然,代码覆盖率反映的仅仅是已有代码的哪些逻辑被执行过了,哪些逻辑还没有被执行
    过。以此为依据,你可以补充测试用例,可以去测试那些还没有覆盖到的执行路径。但也是
    仅此而已,对于那些压根还没有代码实现的部分,基于代码覆盖率的统计指标就无能为力
    了。
    总结来讲,高的代码覆盖率不一定能保证软件的质量,但是低的代码覆盖率一定不能能保证
    软件的质量。
    好了,现在你已经了解了代码覆盖率的概念、价值和局限性,那么接下来,我就以 Java 代
    码覆盖率工具为例,给你解释一下代码覆盖率工具的内部实现原理以及一些关键技术。
    当你理解了这部分内容,以后再面对各个不同开发语言的不同代码覆盖率工具时,就可以做
    到胸有成竹地根据具体的项目性质,选择最合适的代码覆盖率工具了。
    代码覆盖率工具
    JaCoCo 是一款 Java 代码的主流开源覆盖率工具,可以很方便地嵌入到 Ant、Maven 中,
    并且和很多主流的持续集成工具以及代码静态检查工具,比如 Jekins 和 Sonar 等,都有很
    好的集成。
    首先,我先带你看看 JaCoCo 的代码覆盖率报告长什么样子。
    如图 1 所示为 JaCoCo 的整体代码覆盖率统计报告,包括了每个 Java 代码文件的行覆盖率
     
    如图 2 所示为每个 Java 文件内部详细的代码覆盖率情况,图中绿色的行表示已经被覆盖,
    红色的行表示尚未被覆盖,黄色的行表示部分覆盖;左侧绿色菱形块表示该分支已经被完全
    覆盖、黄色菱形块表示该分支仅被部分覆盖。
     
     
     
    展开全文
  • 覆盖率验证——代码覆盖率+功能覆盖率

    万次阅读 多人点赞 2020-04-25 14:52:32
    文章目录一、基于覆盖率驱动的验证技术二、代码覆盖率功能覆盖率三、功能覆盖率建模3.1.功能覆盖率模型——covergroup3.2.覆盖点——coverpoint3.3.覆盖点的——bins四、代码code 一、基于覆盖率驱动的验证技术 采用...

    一、基于覆盖率驱动的验证技术

       采用覆盖率驱动的验证方式可以量化验证进度,保证验证的完备性。一般在验证计划中会指定具体的覆盖率目标。通过覆盖率验证可以确定验证是否达到要求。当然,达到目标覆盖率并不意味着验证就通过了,因为功能覆盖率是由人为定义的,有时候即便达到100%,也未必将所有的功能场景全部覆盖了,因为人为主观定义的功能场景有时候可能存在遗漏,所以还需要对测试用例进行迭代。

    二、代码覆盖率与功能覆盖率

    1. 代码覆盖率:工具会自动搜集已经编写好的代码,常见的代码覆盖率如下:
    • 行覆盖率(line coverage):记录程序的各行代码被执行的情况。
    • 条件覆盖率(condition coverage):记录各个条件中的逻辑操作数被覆盖的情况。
    • 跳转覆盖率(toggle coverage):记录单bit信号变量的值为0/1跳转情况,如从0到1,或者从1到0的跳转。
    • 分支覆盖率(branch coverage):又称路径覆盖率(path coverage),指在if,case,for,forever,while等语句中各个分支的执行情况。
    • 状态机覆盖率(FSM coverage):用来记录状态机的各种状态被进入的次数以及状态之间的跳转情况。
    1. 功能覆盖率:`是一种用户定义的度量,主要是衡量设计所实现的各项功能,是否按预想的行为执行,即是否符合设计说明书的功能点要求,功能覆盖率主要有两种如下所示:
    • 面向数据的覆盖率(Data-oriented Coverage)-对已进行的数据组合检查.我们可以通过编写覆盖组coverage groups)、覆盖点coverage points)和交叉覆盖cross coverage)获得面向数据的覆盖率.
    • 面向控制的覆盖率(Control-oriented Coverage)-检查行为序列sequences of behaviors)是否已经发生.通过编写SVA来获得断言覆盖率(assertion coverage).

    需要指出的是: 代码覆盖率达到要求并不意味着功能覆盖率也达到要求,二者无必然的联系。而为了保证验证的完备性,在收集覆盖率时,要求代码覆盖率和功能覆盖率同时达到要求。

    三、功能覆盖率建模

    功能覆盖率主要关注设计的输入、输出和内部状态,通常以如下方式描述信号的采样要求;

    • 对于输入,它检测数据端的输入和命令组合类型,以及控制信号与数据传输的组合情况。
    • 对于输出,它检测是否有完整的数据传输类别,以及各种情况的反馈时序。
    • 对于内部设计,需要检查的信号与验证计划中需要覆盖的功能点相对应。通过对信号的单一覆盖、交叉覆盖或时序覆盖来检查功能是否被触发,以及执行是否正确。

    3.1.覆盖组——covergroup

       使用覆盖组结构(covergroup)定义覆盖模型,覆盖组结构(covergroup construct)是一种用户自定义的结构类型,一旦被定义就可以创建多个实例就像类(class)一样,也是通过new()来创建实例的。覆盖组可以定义在module、program、interface以及class中。

    每一个覆盖组(covergroup)都必须明确一下内容:

    • 一个时钟事件以用来同步对覆盖点的采样;
    • 一组覆盖点(coverage points),也就是需要测试的变量
    • 覆盖点之间的交叉覆盖;
    • 可选的形式参数;
    • 覆盖率选项;
    covergroup cov_grp @(posedge clk);    //用时钟明确了覆盖点的采样时间,上升沿采样覆盖点,也可省略clk,在收集覆盖率时在根据情况注明
      cov_p1: coverpoint a;//定义覆盖点,cov_p1为覆盖点名,a为覆盖点中的变量名,也就是模块中的变量名
    endgroup
     
    cov_grp cov_inst = new();//实例化覆盖组
    

      上述例子用时钟明确了覆盖点的采样时间,上升沿采样覆盖点,也可省略clk,在收集覆盖率时在根据情况注明,如下示例:

    covergroup cov_grp;
      cov_p1: coverpoint a;//cov_p1为覆盖点名,a为覆盖点中的变量名,也就是模块中的变量名
    endgroup
     
    cov_grp cov_inst = new();
    cov_inst.sample();          //sample函数收集覆盖率
    

      上面的例子通过内建的sample()方法来触发覆盖点的采样.

    logic [7:0] address;
    covergroup address_cov (ref logic [7:0] address,        //添加形式参数
           input int low, int high) @ (posedge ce);
        ADDRESS : coverpoint address {
          bins low    = {0,low};
          bins med    = {low,high};
        }
      endgroup
     
    address_cov acov_low  = new(addr,0,10);
    address_cov acov_med  = new(addr,11,20);
    address_cov acov_high = new(addr,21,30);
    

       覆盖组中允许带形式参数,外部在引用覆盖组时可以通过传递参数,从而对该覆盖组进行复用。

    3.2.覆盖点——coverpoint

      一个覆盖组可以包含多个覆盖点,每个覆盖点有一组显式bins值,bins值可由用户自己定义,每个bins值与采样的变量或者变量的转换有关。一个覆盖点可以是一个整型变量也可以是一个整型表达式。覆盖点为整形表达式的示例如下:注意覆盖点表达式写法。

    class Transaction();
       rand bit[2:0]  hdr_len;       //取值:0~7
       rand bit[3:0]  payload_len;   //取值:0~15
       ...
    endclass
    
    Transaction   tr;
    
    covergroup Cov;
       len16: coverpoint(tr.hdr_len + tr.payload_len);    //注:取值范围为0~15
       len32:coverpoint(tr.hdr_len + tr.payload_len + 5'b0);   //注:取值范围为0~31
    endgroup
    

      当进行仿真后,len16的覆盖点覆盖率最高可达100%,而覆盖点len32的覆盖率最高只能达到23/32=71.87%。由于总的bins数量为32个,而实际最多只能产生产生len_0,len_1,len2,…,len22共23个bins,所以覆盖率永远不可能达到100%。

      如果要使覆盖点len32达到100%的覆盖率,可以手动添加自定义bins,代码如下:

    covergroup Cov;
       len32:coverpoint(tr.hdr_len + tr.payload_len + 5'b0);   //注:取值范围为0~31  
                        {bins  len[] = {[0:22]};} 
    endgroup
    

      此时将覆盖点的范围限定在0~22之间,符合覆盖点的实际取值范围,故覆盖率可以达到100%。

    3.3.覆盖点元素——隐式bin与显式bins

    • 隐式或自动bin:覆盖点变量,其取值范围内的每一个值都会有一个对应的bin,这种称为自动或隐式的bin。例如,对于一个位宽为nbit的覆盖点变量,若不指定bin个数,2^n个bin将会由系统自动创建,需要注意的是 自动创建bin的最大数目由auto_bin_max内置参数决定,默认值64
    program automatic test(busifc.TB ifc);        //接口例化
       class Transaction;
          rand bit [3:0]  data;
          rand bit [2:0]  port;
       endclass
    
       covergroup Cov;           //定义覆盖组,未添加时钟信号,此时需要使用sample()函数采集覆盖率
          coverpoint  tr.port;     //设置覆盖点
       endgroup
    
       initial begin
          Transaction  tr=new();     //例化数据包
          Cov          ck=new();     //例化覆盖组
          repeat(32) begin
             tr.randomize();
             ifc.cb.port <= tr.port;
             ifc.cb.data <= tr.data;
             ck.sample();            //采集覆盖率
             @ifc.cb;
          end
       end
       
    endprogram   
    

    对于覆盖点tr.port,如果覆盖率达到100%,那么将会有auto[0],auto[1],auto[2] … auto[7]等8个bin被自动创建。其实际功能覆盖率报告如下:
    在这里插入图片描述

    • 显式bins:"bins"关键字被用来显示定义一个变量的bin,用户自定义bin可以增加覆盖的准确度,它属于功能覆盖率的一个衡量单位。在每次采样结束时,生成的数据库中会包含采样后的所有bins,显示其收集到的具体覆盖率值。最终的覆盖率等于采样的bins值除以总的bins值。
    covergroup 覆盖组名 @(posedge clk);//时钟可以没有
      覆盖点名1: coverpoint 变量名1{ bins bin名1 = {覆盖点取值范围}(iff(expression));  //iff结构可以指定采样条件
                                    bins bin名2 = {覆盖点取值范围};
                                    bins bin名3 = {覆盖点取值范围};
                                  .......
                                  }//一般会将bin的数目限制在8或16
                               。。。。。。
    endgroup : 覆盖组名
    
    iff结构的运用实例如下:
    bit[1:0]  s0;
    covergroup  g4;
      cover1: coverpoint s0 iff(!reset) ;    //当reset=0时,表达式为真开始采样 
    endgroup
     
    //注意对coverpoint的bin的声明使用的是{},这是因为bin是声明语句而非程序语句,而且{}后也没有加分号
    

      针对某一变量,我们关心的可能只是某些区域的值或者跳转点,因此我们可以在显示定义的bins中指定一组数值(如3,5,6)或者跳转序列(如3->5->6) 显示定义bins时,可通过关键字default将未分配到的数值进行分配

    covergroup  Cov;
       coverpoint  tr.data{             //data变量的取值范围为0~15,不设置显示bins时,理论上会有16个bin
                   bins  zero = {0};            //取值:0
                   bins  lo = {[1:3],5};        //取值:1,2,3,5
                   bins  hi[] = {[8:$]};        //取值:8~15,使用动态数组方法时相当于创建了hi[0],hi[1],...,hi[7]一共8个bins
                   bins  misc = default;        //余下的所有值:4,6,7
       }
    

    其部分覆盖率报告如下:
    在这里插入图片描述

    3.4.覆盖点的状态跳转——=> 与 ?通配符

      除了在bins中定义数值,还可以定义数值之间的跳转,操作符(=>),如下所示:

    bit[2:0]     v;
    covergroup  sg@(posedge clk);
       coverpoint  v{bins b1=(3=>4),(4=>5),(5=>6);   
                     bins b2=(3 => 4 => 5);   //跳转次序为 3->4->5,如果没有执行这个次序,则这个bins没有覆盖
                     bins b3=(1,5 => 6,7);   //(1=>6)、(1=>7)、(5=>6)、(5=>7)
                     bins b5=(5[*3]);         //3 consecutive 5's(连续重复,数值5的3次重复连续)
                     bins b6=(3[*3:5]);       //(3=>3=>3)、(3=>3=>3=>3)、(3=>3=>3=>3=>3)
                     bins b7=(4[->3]=>5);     //...=>4...=>4...=>4=>5(跟随重复,4出现3次,可以不连续,但在最后一个4出现后,下一个数值为5)
                     bins b8=(2[=3]=>5);      //...=>2...=>2...=>2...=>5(非连续重复,数值2出现3次)
                     bins anothers=default_sequence;
                     }
    endgroup
    
    

      除操作符外,还可使用关键词wildcard通配符?来表示状态和状态跳转;

    
    wildcard bins abc = {2'b1?};//覆盖10,11
     
    wildcard bins abc = (2'b1x => 2'bx0};
     
    //覆盖 10=>00 ,10=>10 ,11=>00 ,11=>10
     
    covergroup address_cov () @ (posedge ce);
      ADDRESS : coverpoint addr {
        // Normal transition bibs
        wildcard bins adr0  = {3'b11?};
        // We can use wildcard in transition bins also
        wildcard bins adr1  = (3'b1x0 => 3'bx00);
        wildcard bins adr2  = (3'b1?0 => 3'b?00);
      }
    endgroup
    
    ————————————————
    原文链接:https://blog.csdn.net/bleauchat/article/details/90445713
    

    3.4.覆盖点之间的交叉覆盖率——cross

      交叉覆盖是在覆盖点或变量之间指定的,必须先指定覆盖点,然后通过关键字cross定义覆盖点之间的交叉覆盖

    //通过覆盖点来定义交叉覆盖
    bit [3:0] a, b;
    covergroup cg @(posedge clk);
      c1: coverpoint a;
      c2: coverpoint b;
      c1Xc2: cross c1,c2;    //1. 定义交叉覆盖使用关键字cross,利用**覆盖点名字**定义交叉覆盖
    endgroup : cg
     
    //通过变量名来定义交叉覆盖
    bit [3:0] a, b;
    covergroup cov @(posedge clk);
      aXb : cross a, b;      //2. 定义交叉覆盖使用关键字cross,直接利用**变量名字**定义交叉覆盖
    endgroup
     
    //交叉覆盖的通用定义格式: 
    交叉覆盖名:cross 交叉覆盖点名1,交叉覆盖点名2;
    

       由于上面每个覆盖点都有16个bin,所以它们的交叉覆盖总共有256(16*16)个交叉积(cross product),也就对应256个bin

    bit [3:0] a, b, c;
    covergroup cov @(posedge clk);
      BC  : coverpoint b+c;
      aXb : cross a, BC;
    endgroup
    

    上例的交叉覆盖总共有256个交叉积(cross product),也对应256个bin.

    3.6.覆盖率的选项与方法

    • at_least——覆盖阈值,定义一个bin在执行代码过程中至少触发的次数,低于这个触发次数的话,这个bin不算覆盖,默认值是1;
    • auto_bin_max——当没有bin为显示创建时,定义一个覆盖点的自动bin的最大数量,默认值为64;
    • cross_auto_bin_max——定义一个交叉覆盖的交叉积(cross product)的自动bin的最大数量,没有默认值;
    covergroup cg @(posedge clk);
      c1: coverpoint addr  { option.auto_bin_max = 128;}//addr自动bin的数目最大为128
      c2: coverpoint wr_rd { option.at_least = 2;}//wr_rd的每个bin至少要触发两次,否则不算覆盖
      c1Xc2: cross c1, c2  { option.cross_auto_bin_max = 128;}//交叉积的自动bin数目最大为128
    endgroup : cg
    
    //覆盖选项如果是在某个coverpoint中定义的,那么其作用范围仅限于该coverpoint;
    //如果是在covergroup中定义的,那么其作用范围是整个covergroup;
    

    四、代码code——约束与覆盖率的运用

    • void sample() : Triggers the sampling of covergroup 触发覆盖组的采样
    • real get_coverage() : Calculate coverage number, return value will be 0 to 100 返回覆盖组覆盖率
    • real get_inst_coverage() :Calculate coverage number for given instance, return value will be 0 to 100 返回覆盖组实例的覆盖率
    • void set_inst_name(string) :Set name of the instance with given string 设置实例名
    • void start() :Start collecting coverage 开启覆盖率收集
    • void stop() :Stop collecting coverage 结束收集覆盖率
    module test();
     
    logic [2:0] addr;
    wire [2:0] addr2;
     
    assign addr2 = addr + 1;
     
    covergroup address_cov;
      ADDRESS : coverpoint addr {
        option.auto_bin_max = 10;
      }
      ADDRESS2 : coverpoint addr2 {
        option.auto_bin_max = 10;
      }
    endgroup
     
    address_cov my_cov = new;
     
    initial begin
      my_cov.ADDRESS.option.at_least = 1;
      my_cov.ADDRESS2.option.at_least = 2;
      // start the coverage collection
      my_cov.start();
      // Set the coverage group name
      my_cov.set_inst_name("ASIC-WORLD");
      $monitor("addr 8'h%x addr2 8'h%x",addr,addr2);
      repeat (10) begin
        addr = $urandom_range(0,7);
        // Sample the covergroup
        my_cov.sample();
        #10;
      end
      // Stop the coverage collection
      my_cov.stop();
      // Display the coverage
      $display("Instance coverage is %e",my_cov.get_coverage());
    end
     
    endmodule
    

    4.1.通过修改随机化次数——提高覆盖率(覆盖点变量取值范围小)

    1)、在不添加约束constraint、不使用自定义bins,的情况下:

    module cov_demo();
    
      class transaction;
          rand bit[31:0]  data;        //2^32种可能
          rand bit[2:0]  port;         //0~7,一共8种可能
      endclass
        
       covergroup cov_port;
           port_bin : coverpoint tr.port;
           data_bin : coverpoint tr.data;
       endgroup
         
        transaction    tr=new;      //声明类的句柄,创建对象
        cov_port       ck=new;      //声明覆盖组的句柄,创建对象; covergroup和class类似
        
        initial begin
            repeat(4)begin           //生成得数据包的数量会影响覆盖率,也可以通过添加约束constraint来提升覆盖率,或者自定义bins。
                tr.randomize;        //随机化生成数据
                ck.sample();         //搜集覆盖率
            end
        end 
    
    endmodule
    
    

       覆盖率如下:使用Makefile实例三即可。在这里插入图片描述
      可以看出,两个覆盖点cport和cdata的覆盖率都较低,这是由于产生的随机化数据次数太少, 可以通过提高产生随机化的重复次数进一步提高覆盖率
    2)、在不添加约束constraint、不使用自定义bins,**改变随机化次数**的情况下:

            repeat(32)begin           //生成得数据包的数量会影响覆盖率,也可以通过添加约束constraint来提升覆盖率,或者自定义bins。
    

       在将repeat(4)改为repeat(32)后:覆盖率如下:
    在这里插入图片描述
      需要指出的是,提高随机化次数来提高覆盖率的方法只适用于,覆盖点的变量本身取值范围不大(如cport)的情况,如cdata自身取值范围太大,此方法便不再适用。此时可以通过添加约束constraint提高覆盖率
    在这里插入图片描述

    4.2.通过添加约束constraint、自定义bins——提高覆盖率(覆盖点变量取值范围大)

    1)、在自定义bins,而不添加约束constraint的情况下:

    module cov_demo();
    
      class transaction;
          rand bit[31:0]  data;        //2^32种可能
          rand bit[2:0]  port;         //0~7,一共8种可能
      endclass
        
       covergroup cov_port;
           port_bin : coverpoint tr.port;
           data_bin : covergroup tr.data{
                             bins min={[0:100]};        //此时,随机化生成该范围内任意一个数,该bins便被覆盖
                             bins mid={[101:9999]};
                             bins max={[10000:$]};       //$—-表示最大的边界
                          }
        endgroup
         
        transaction    tr=new;      //声明类的句柄,创建对象
        cov_port       ck=new;      //声明覆盖组的句柄,创建对象; covergroup和class类似
        
        initial begin
            repeat(32)begin           //生成得数据包的数量会影响覆盖率,也可以通过添加约束constraint来提升覆盖率,或者自定义bins。
                tr.randomize;        //随机化生成数据
                ck.sample();         //搜集覆盖率
            end
        end 
    
    endmodule
    

    在这里插入图片描述
    2)、在自定义bins,添加约束constraint的情况下:

    module cov_demo();
    
      class transaction;
          rand bit[31:0]  data;        //2^32种可能
          rand bit[2:0]  port;         //0~7,一共8种可能
          constraint data_c1{
                        data inside {[0:100],[101:9999],[10000:12000]};       //由于data的可能性太多,故对其施加约束
                        }
       endclass
        
       covergroup cov_port;
           port_bin : coverpoint tr.port;
           data_bin : covergroup tr.data{
                             bins min={[0:100]};        //此时,随机化生成该范围内任意一个数,该bins便被覆盖
                             bins mid={[101:9999]};
                             bins max={[10000:$]};       //$—-表示最大的边界
                          }
        endgroup
         
        transaction    tr=new;      //声明类的句柄,创建对象
        cov_port       ck=new;      //声明覆盖组的句柄,创建对象; covergroup和class类似
        
        initial begin
            repeat(32)begin           //生成得数据包的数量会影响覆盖率,也可以通过添加约束constraint来提升覆盖率,或者自定义bins。
                tr.randomize;        //随机化生成数据
                ck.sample();         //搜集覆盖率
            end
        end 
    
    endmodule
    

    在这里插入图片描述
    将随机化的次数改为320次后,repeat(320):覆盖率的hit次数变化分布不明显,如下图:可以通过施加权重调整hit的次数分布.
    在这里插入图片描述

    4.3.通过权重dist——调整hit次数分布

    将代码中的constraint约束调整为权重dist处理后,其各个bins的hit次数分布更加均匀,如下所示:

          constraint data_c1{
              data dist {[0:100]:/ 100, [101:9999]:/ 100, [10000:12000]:/ 120};      
                        }
    

    在这里插入图片描述

    展开全文
  • 这对于开发人员和测试人员都非常重要,因为当开发人员生成具有高级别代码覆盖率的代码时,测试团队可以专注于代码是否满足业务目标,而不是被很多低级代码缺陷所困扰。 当代码覆盖量特别重要时 以下情况是代码...
  • 这个项目展示了如何从Storybook收集代码覆盖率(例如,当使用进行视觉回归测试时)以及如何为3种类型的测试创建组合的代码覆盖率报告: 视觉回归测试(/) 单元测试() 集成测试() 您可以查看每种测试的报告...
  • Jacoco增量代码覆盖率工具使用心得

    千次阅读 2019-12-04 19:09:52
    写在前面 这是本人第一次写博文,之前有很多问题及学习过程均...Jacoco 是一个开源的覆盖率工具。Jacoco 可以嵌入到 Ant 、Maven 中,并提供了 EclEmma Eclipse 插件,也可以使用 Java Agent 技术监控 Java 程序。很...
  • go单元测试及代码覆盖率

    千次阅读 2019-05-07 11:35:05
    Go语言官方则提供了语言级的单元测试支持,即testing包,而且仅通过go工具本身就可以方便地生成覆盖率数据,也就是说,单元测试是Go语言的自带属性,除了好好设计自己的单元测试用例外,开发者不需要操心工程搭建的...
  • python代码覆盖率

    千次阅读 2016-12-28 19:29:07
    python代码覆盖率,使用的coverage包,生成代码覆盖率报告。 1 安装coverage: $ pip install coverage2 python代码覆盖率生成:  执行代码覆盖率统计 #coverage run my_test.py arg1 arg2 启动覆盖率测试,跑完...
  • CM = -cm line+cond+fsm_branch+tgl //表示要收集的代码覆盖率类型 CM_NAME = -cn_name $(OUTPUT) //表示覆盖率的文件名 CM_DIR = -cm_dir ./$(OUTPUT).vdb //表示覆盖率要存放到哪个目录下 -cm_nocasedef /
  • Cadence IUS 之三:代码覆盖率分析

    千次阅读 2019-04-23 21:08:41
    1)irun 由irun产生coverage数据。 irun 加-coverage all(表示对所有类型的coverage都产生数据)和-covtest TB_NAME(指定将要产生的数据... 跑完仿真,自动生成cov_work/scope/TB_CASE1 覆盖率数据。 2)imc...
  • 显示代码覆盖率百分比,以及按类型(危险,风险,可接受,安全)分类的覆盖状态 先决条件 此插件依赖于由runTest任务生成的coverage.json文件。 为什么使用这个插件? 此插件非常适合生成Salesforce组织的代码覆盖...
  • 一、项目使用覆盖率初衷 由于公司开发项目业务类型是给企业做定制项目,开发周期短。开发人员在开发过程中往往在将项目提交给测试组测试时,没有进行全面项目...二、覆盖率概念 代码覆盖率分析实际上一种度量方式,间
  • Python代码覆盖率工具——Coverage_API

    千次阅读 2019-10-29 17:47:43
    在我们进行代码覆盖率统计时,可以过滤你不想进行代码覆盖率统计的py文件以及代码(配置对应py文件的路径),需要创建一个.coveragerc文件进行过滤,然后在进行代码覆盖率统计时就会忽略掉.coveragerc文件里面设置的...
  • 代码覆盖率需要注意的点

    千次阅读 2018-08-13 15:12:53
    确实代码覆盖可以找出测试疏漏和代码问题,但是单纯的代码覆盖率高低并不能直接反映代码质量的好坏。大多我们的努力方向都是找出那些没有覆盖到的代码,然后补充用例,完善测试。而摆在我们面前的问题是:是否我们...
  • gitlab项目通过ci/cd产生code coverage代码覆盖率背景调查方案gitlab项目gitlab-ci.yml设置gitlab runner安装与配置codecoverage结果展示trouble shouting:总结 背景 gitlab项目需要统计**code coverage ** ,一个同...
  • 如何使用JaCoco统计代码覆盖率

    千次阅读 2020-05-26 18:56:30
    通过Jenkins插件,能够通过pipline的方式同时显示构建的流程及代码覆盖率视图 即:通过在Jenkinsfile文件中定义stage和shell脚本,来显示覆盖率 背景 Jenkins服务器+jacoco插件 编译环境:maven 项目结构:...
  • 使用 JaCoCo 统计功能测试代码覆盖率? 对于 JaCoCo,有所了解但又不是很熟悉。 "有所了解"指的是在 CI 实践中已经使用 JaCoCo 对单元测试代码覆盖率统计: 当代码 push 到代码仓库后,用 JaCoCo 进行单元测试代码...
  • 基于黑盒测试的代码覆盖率的实现

    千次阅读 2017-08-10 15:06:18
    那如何对黑盒测试进行代码覆盖率的统计 呢?下面我们step by step来看黑盒测试的覆盖率实现。 1. 首先我们选择cobertura工具来做覆盖率,可以使用命令行,也可以结合maven来实现。由于测试往往没有对开发代码的修改...
  • 可以在gcc/g++工具编译代码时加上“–coverage”选项来生成可用于覆盖率分析的二进制文件,然后用gcov命令来生成覆盖率统计情况,也可用lcov工具来生成html版本的可读性很好的代码覆盖率报告。 下面列举一下各种...
  • C++语言的单元测试与代码覆盖率

    千次阅读 2018-11-20 11:32:44
    直接交付没有经过测试的代码是不太好的,因为这很可能会浪费整个团队的时间,在一些原本早期就可以发现的问题上。而单元测试,就是发现问题一个很重要的环节。 本文以C++语言为基础,讲解如何进行单元测试并生成测试...
  • 什么叫代码覆盖率

    千次阅读 2013-03-30 19:46:31
    什么叫代码覆盖率 什麼叫代碼覆蓋率?它的作用是什麼?在測試流程過程中,它什麼時候做?另外,有什麼工具可以實現該功能?它與開發代碼中的代碼覆蓋率有什麼區別沒? 在測試中的代碼覆蓋率是指,你运行测试用例后,...
  • 在做接口测试过程中,为了达到量化接口测试用例效果的目的,引入了代码覆盖率作为重要指标,在查阅相关文档和资料通过实践之后,大概得到了一个方案。如图: 备注:该方案略微复杂了一些,原因在于服务JVM所在的...
  • android studio下常用的单元测试类型有Android Junit和Android Instrumented Tests等,这里说下前者。 Android Junit仅需jvm,运行在本地,无需android设备或者模拟器;在较新的AS版本中创建项目,会自动生成两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,442
精华内容 39,776
关键字:

代码覆盖率类型