精华内容
下载资源
问答
  • jacoco统计手动测试覆盖率工具文件

    热门讨论 2016-11-25 17:42:12
    配合教程使用http://blog.csdn.net/cxq234843654/article/details/53337935,一个自己写的统计黑盒测试覆盖率的工具
  • 覆盖率验证——代码覆盖率+功能覆盖

    万次阅读 多人点赞 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};      
                        }
    

    在这里插入图片描述

    展开全文
  • java代码覆盖率 jacoco 原理解析

    千人学习 2019-04-16 00:23:45
           有人了解些jacoco的原理,也能够进行些实操,但不能将原理与实操联系起来。为了解决这一问题特为大家输出本课程,以便更好地理解jacoco且在实战中能够得心应手,遇到问题后也...
  • 算法:棋盘覆盖问题

    千次阅读 多人点赞 2019-10-09 20:04:47
    如何应用分治法求解棋盘覆盖问题呢?分治的技巧在于如何划分棋盘,使划分后的子棋盘的大小相同,并且每个子棋盘均包含一个特殊方格,从而将原问题分解为规模较小的棋盘覆盖问题。k>0时,可将2k×2k的棋盘划分为4...

    如何应用分治法求解棋盘覆盖问题呢?分治的技巧在于如何划分棋盘,使划分后的子棋盘的大小相同,并且每个子棋盘均包含一个特殊方格,从而将原问题分解为规模较小的棋盘覆盖问题。k>0时,可将2k×2k的棋盘划分为4个2(k-1)×2(k-1)的子棋盘,如图4.11(a)所示。这样划分后,由于原棋盘只有一个特殊方格,所以,这4个子棋盘中只有一个子棋盘包含该特殊方格,其余3个子棋盘中没有特殊方格。为了将这3个没有特殊方格的子棋盘转化为特殊棋盘,以便采用递归方法求解,可以用一个L型骨牌覆盖这3个较小棋盘的会合处,如图4.11(b)所示,从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种划分策略,直至将棋盘分割为1×1的子棋盘。

    算法实现:
    (1)棋盘:可以用一个二维数组board[size][size]表示一个棋盘,其中,size=2^k。为了在递归处理的过程中使用同一个棋盘,将数组board设为全局变量;
    (2)子棋盘:整个棋盘用二维数组board[size][size]表示,其中的子棋盘由棋盘左上角的下标tr、tc和棋盘大小s表示;
    (3)特殊方格:用board[dr][dc]表示特殊方格,dr和dc是该特殊方格在二维数组board中的下标;
    (4) L型骨牌:一个2k×2k的棋盘中有一个特殊方格,所以,用到L型骨牌的个数为(4^k-1)/3,将所有L型骨牌从1开始连续编号,用一个全局变量t表示。
    设全局变量t已初始化为0
    C++实现:

    #include <iostream>
    using namespace std;
    
    int tile = 1;//全局变量 骨牌编号
    int Board[8][8];//棋盘
    void ChessBoard(int tr,int tc,int dr,int dc,int size);
    
    int main()
    {
    	for(int i=0; i<8; i++)
    	{
    		for(int j=0; j<8; j++)
    		{
    			Board[i][j] = 0;
    		}
    	}
    
    	ChessBoard(0,0,2,3,8);
    
    	for(int i=0; i<8; i++)
    	{
    		for(int j=0; j<8; j++)
    		{
    			printf("%4d",Board[i][j]);
    		}
    		cout<<endl;
    	}
    }
    
    /**
     * tr : 棋盘左上角的行号,tc棋盘左上角的列号
     * dr : 特殊方格左上角的行号,dc特殊方格左上角的列号
     * size :size = 2^k 棋盘规格为2^k*2^k
     */
    void ChessBoard(int tr,int tc,int dr,int dc,int size)
    {
    	if(size == 1)
    	{
    		return;
    	}
    	int t = tile++;//L型骨牌编号
    	int s = size/2;//分割棋盘
    
    	//覆盖左上角子棋盘
    	if(dr<tr+s && dc<tc+s)//特殊方格在此棋盘中
    	{
    		ChessBoard(tr,tc,dr,dc,s);
    	}
    	else//特殊方格不在此棋盘中
    	{
    		//用编号为t的骨牌覆盖右下角
    		Board[tr+s-1][tc+s-1] = t;
    		//覆盖其余方格
    		ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
    	}
    
    	//覆盖右上角子棋盘
    	if(dr<tr+s && dc>=tc+s)//特殊方格在此棋盘中
    	{
    		ChessBoard(tr,tc+s,dr,dc,s);
    	}
    	else//特殊方格不在此棋盘中
    	{
    		//用编号为t的骨牌覆盖左下角
    		Board[tr+s-1][tc+s] = t;
    		//覆盖其余方格
    		ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
    	}
    
    	//覆盖左下角子棋盘
    	if(dr>=tr+s && dc<tc+s)//特殊方格在此棋盘中
    	{
    		ChessBoard(tr+s,tc,dr,dc,s);
    	}
    	else//特殊方格不在此棋盘中
    	{
    		//用编号为t的骨牌覆盖右上角
    		Board[tr+s][tc+s-1] = t;
    		//覆盖其余方格
    		ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
    	}
    
    	//覆盖右下角子棋盘
    	if(dr>=tr+s && dc>=tc+s)//特殊方格在此棋盘中
    	{
    		ChessBoard(tr+s,tc+s,dr,dc,s);
    	}
    	else//特殊方格不在此棋盘中
    	{
    		//用编号为t的骨牌覆盖左上角
    		Board[tr+s][tc+s] = t;
    		//覆盖其余方格
    		ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
    	}
    
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • 覆盖

    千次阅读 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
    
    展开全文
  • 本demo实现的是基于百度地图覆盖物的修改和点击以及实现自定义区域全覆盖的功能,里面的Key需要你自己申请的,以及包名。 希望对刚刚接触百度地图的人有所帮助。
  • powerdesigner 16.5 破解文件dll文件 直接覆盖即可

    千次下载 热门讨论 2013-03-21 12:50:49
    google上的16.5破解文件竟然是个下载软件的假链接,一怒之下只好自己动手丰衣足食。...powerdesigner 16.5 破解文件下载后覆盖到安装目录即可。试用版版本信息不会变化,但是软件license不会过期。
  • j S:returnj 二、设计测试用例 1、语句覆盖 测试用例 覆盖的语句 覆盖路径 输入: x = 4 , y = 4 , z = 2 x=4,y=4,z=2 x=4,y=4,z=2 输出: j = 2 j=2 j=2 k = 0 , j = 0 k=0,j=0 k=0,j=0 k = x ∗ y − 1 , j = s q r ...

    一、流程图

    根据需求画出流程图

    1、两个判定

    M M M

    N N N

    2、两个条件

    M = ( x > 3 ) & & ( z < 10 ) ) M={(x>3) \&\& (z<10))} M=(x>3)&&(z<10))

    N = ( x = = 4 ) ∣ ∣ ( y > 5 ) N={(x==4)||(y>5)} N=(x==4)(y>5)

    3、四条路径

    P 1 ( 1 − 2 − 4 − 5 − 7 − 8 − 9 − 10 ) : M & & N P1(1-2-4-5-7-8-9-10):M \&\& N P1(124578910):M&&N
    P 2 ( 1 − 2 − 4 − 5 − 7 − 9 − 10 ) : M & & ¬ N P2(1-2-4-5-7-9-10):M \&\& \lnot N P2(12457910):M&&¬N
    P 3 ( 1 − 2 − 7 − 8 − 9 − 10 ) : ¬ M & & N P3(1-2-7-8-9-10):\lnot M \&\& N P3(1278910):¬M&&N
    P 4 ( 1 − 2 − 7 − 9 − 10 ) : ¬ M & & ¬ N P4(1-2-7-9-10):\lnot M \&\& \lnot N P4(127910):¬M&&¬N

    4、五条语句

    O : k = 0 , j = 0 O:k=0,j=0 O:k=0,j=0
    P : k = x ∗ y − 1 , j = s q r t ( k ) P:k=x*y-1, j=sqrt(k) P:k=xy1,j=sqrt(k)
    Q : j = x ∗ y + 10 Q:j=x*y+10 Q:j=xy+10
    R : j = j % 3 R:j=j\%3 R:j=j%3
    S : r e t u r n    j S:return \;j S:returnj

    二、设计测试用例

    1、语句覆盖

    测试用例覆盖的语句覆盖路径
    输入: x = 4 , y = 4 , z = 2 x=4,y=4,z=2 x=4,y=4,z=2
    输出: j = 2 j=2 j=2
    k = 0 , j = 0 k=0,j=0 k=0,j=0
    k = x ∗ y − 1 , j = s q r t ( k ) k=x*y-1, j=sqrt(k) k=xy1,j=sqrt(k)
    j = x ∗ y + 10 j=x*y+10 j=xy+10
    j = j % 3 j=j\%3 j=j%3
    r e t u r n    j return \;j returnj
    P 1 ( 1 − 2 − 4 − 5 − 7 − 8 − 9 − 10 ) P1(1-2-4-5-7-8-9-10) P1(124578910)

    2、判定覆盖

    测试用例判定M的取值判定N的取值覆盖路径
    输入: x = 4 , y = 4 , z = 2 x=4,y=4,z=2 x=4,y=4,z=2
    输出: j = 2 j=2 j=2
    TT P 1 ( 1 − 2 − 4 − 5 − 7 − 8 − 9 − 10 ) P1(1-2-4-5-7-8-9-10) P1(124578910)
    输入: x = 2 , y = 2 , z = 5 x=2,y=2,z=5 x=2,y=2,z=5
    输出: j = 0 j=0 j=0
    FF P 4 ( 1 − 2 − 7 − 9 − 10 ) P4(1-2-7-9-10) P4(127910)

    3、条件覆盖

    对于 M M M:
    x > 3 取 真 时 T 1 , 取 假 时 F 1 x>3取真时T1,取假时F1 x>3T1,F1
    z < 10 取 真 时 T 2 , 取 假 时 F 2 z<10取真时T2,取假时F2 z<10T2,F2


    对于 N N N:
    x = = 4 取 真 时 T 3 , 取 假 时 F 3 x==4取真时T3,取假时F3 x==4T3,F3
    y > 5 取 真 时 T 4 , 取 假 时 F 4 y>5取真时T4,取假时F4 y>5T4,F4

    测试用例取值条件具体取值条件覆盖路径
    输入: x = 4 , y = 4 , z = 2 x=4,y=4,z=2 x=4,y=4,z=2
    输出: j = 2 j=2 j=2
    T 1 , T 2 , T 3 , T 4 T1,T2,T3,T4 T1,T2,T3,T4 x > 3 , z < 10 , x = = 4 , y > 5 x>3,z<10,x==4,y>5 x>3,z<10,x==4,y>5 P 1 ( 1 − 2 − 4 − 5 − 7 − 8 − 9 − 10 ) P1(1-2-4-5-7-8-9-10) P1(124578910)
    输入: x = 2 , y = 2 , z = 11 x=2,y=2,z=11 x=2,y=2,z=11
    输出: j = 0 j=0 j=0
    F 1 , F 2 , F 3 , F 4 F1,F2,F3,F4 F1,F2,F3,F4 x < = 3 , z > = 10 , x ! = 4 , y < = 5 x<=3,z>=10,x!=4,y<=5 x<=3,z>=10,x!=4,y<=5 P 4 ( 1 − 2 − 7 − 9 − 10 ) P4(1-2-7-9-10) P4(127910)

    4、路径覆盖

    编号覆盖条件取值判定条件取值判定条件组合
    1T1,T2 M M M x > 3 , z < 10 x>3,z<10 x>3,z<10
    2T1,F2 ¬ M \lnot M ¬M x > 3 , z > = 10 x>3,z>=10 x>3,z>=10
    3F1,T2 ¬ M \lnot M ¬M x < = 3 , z < 10 x<=3,z<10 x<=3,z<10
    4F1,F2 ¬ M \lnot M ¬M x < = 3 , z > = 10 x<=3,z>=10 x<=3,z>=10
    5T3,T4 N N N x = = 4 , y > 5 x==4,y>5 x==4,y>5
    6T3,F4 N N N x = = 4 , y < = 5 x==4,y<=5 x==4,y<=5
    7F3,T4 N N N x ! = 4 , y > 5 x!=4,y>5 x!=4,y>5
    8F3,F4 ¬ N \lnot N ¬N x ! = 4 , y < = 5 x!=4,y<=5 x!=4,y<=5
    测试用例覆盖条件覆盖路径覆盖组合
    输入: x = 4 , y = 4 , z = 2 x=4,y=4,z=2 x=4,y=4,z=2
    输出: j = 2 j=2 j=2
    T 1 , T 2 , T 3 , T 4 T1,T2,T3,T4 T1,T2,T3,T4 P 1 ( 1 − 2 − 4 − 5 − 7 − 8 − 9 − 10 ) P1(1-2-4-5-7-8-9-10) P1(124578910)1,5
    输入: x = 10 , y = 5 , z = 8 x=10,y=5,z=8 x=10,y=5,z=8
    输出: j = 1 j=1 j=1
    T 1 , T 2 , F 3 , F 4 T1,T2,F3,F4 T1,T2,F3,F4 P 2 ( 1 − 2 − 4 − 5 − 7 − 9 − 10 ) P2(1-2-4-5-7-9-10) P2(12457910)1,8
    输入: x = 2 , y = 6 , z = 12 x=2,y=6,z=12 x=2,y=6,z=12
    输出: j = 1 j=1 j=1
    F 1 , F 2 , F 3 , T 4 F1,F2,F3,T4 F1,F2,F3,T4 P 3 ( 1 − 2 − 7 − 8 − 9 − 10 ) P3(1-2-7-8-9-10) P3(1278910)4,7
    输入: x = 2 , y = 2 , z = 11 x=2,y=2,z=11 x=2,y=2,z=11
    输出: j = 0 j=0 j=0
    F 1 , F 2 , F 3 , F 4 F1,F2,F3,F4 F1,F2,F3,F4 P 4 ( 1 − 2 − 7 − 9 − 10 ) P4(1-2-7-9-10) P4(127910)4,8

    三、编写Java类,调用该方法,并用Junit测试工具编写测试代码

    
    public class Work {
    
        public int DoWork(int x, int y, int z){
            int k = 0, j = 0;
            if ( (x>3) && (z<10) )
            {
                k = x * y - 1;
                j = (int) Math.sqrt(k);
            }
            if ( (x == 4) || (y>5))
                j = x * y + 10;
            j = j%3;
            return j;
        }
    }
    
    

    测试类的编写

    import org.junit.*;
    
    import static org.junit.Assert.*;
    
    public class WorkTest {
        @BeforeClass
        public static void before()
        {
            System.out.println("Global测试开始");
    
        }
        @AfterClass
        public static void after()
        {
            System.out.println("Global测试结束");
        }
        @Before
        public void setUp() throws Exception{
            System.out.println("-------------");
    
            System.out.println("一个测试开始了");
        }
        @After
        public void tearDown() throws Exception{
            System.out.println("一个测试结束了");
    
        }
        //语句覆盖
        @Test
        public void testStatement(){
            System.out.println("正在进行语句覆盖测试");
            assertEquals(2,new Work().DoWork(4,4,2));
        }
        //判定覆盖
        @Test
        public void testDecision1(){
            System.out.println("正在进行判定覆盖测试1");
            assertEquals(2,new Work().DoWork(4,4,2));
        }
        @Test
        public void testDecision2(){
            System.out.println("正在进行判定覆盖测试2");
    
            assertEquals(0,new Work().DoWork(2,2,5));
    
        }
        //条件覆盖
        @Test
        public void testCondition1(){
            System.out.println("正在进行条件覆盖测试1");
            assertEquals(2,new Work().DoWork(4,4,2));
        }
        @Test
        public void testCondition2(){
            System.out.println("正在进行条件覆盖测试2");
            assertEquals(0,new Work().DoWork(2,2,11));
        }
        //路径覆盖
        @Test
        public void testPath1(){
            System.out.println("正在进行路径覆盖测试1");
            assertEquals(2,new Work().DoWork(4,4,2));
    
        }
        @Test
        public void testPath2(){
            System.out.println("正在进行路径覆盖测试2");
    //        assertEquals(1,new Work().DoWork(5,10,8));错误的用例设计
            assertEquals(1,new Work().DoWork(10,5,7));
    
        }
        @Test
        public void testPath3(){
            System.out.println("正在进行路径覆盖测试3");
            assertEquals(1,new Work().DoWork(2,6,12));
    
        }
        @Test
        public void testPath4(){
            System.out.println("正在进行路径覆盖测试4");
            assertEquals(0,new Work().DoWork(2,2,11));
    
        }
    }
    
    
    
    展开全文
  • 文章目录语句覆盖判定覆盖条件覆盖条件--判定覆盖组合覆盖 逻辑覆盖率:语句覆盖<条件覆盖<判定覆盖<条件-判定覆盖<组合覆盖<路径覆盖 语句覆盖 基本思想:设计用例,使程序中的每个可执行语句至少...
  • systemverilog之覆盖

    千次阅读 2020-06-15 23:23:34
    随着设计变的越来越复杂,覆盖率驱动的验证(CDV, coverage driven verification)成为不可或缺的有效的验证手段,需要覆盖率来保证验证的完备性,以及覆盖的全面性。 覆盖率是呈现的一-组信息,这组信息可以告诉我们...
  • SV之覆盖

    万次阅读 多人点赞 2019-05-22 21:01:29
    Coverage 覆盖率 Functional Coverage 功能覆盖率 Cross Coverage 交叉覆盖 Coverage Options 覆盖率选项 Coverage methods 覆盖率方法 Coverage system task 覆盖率系统任务 Coverage 覆盖覆盖率用来衡量...
  • 代码覆盖

    千次阅读 2018-02-11 13:06:47
    用途:测试覆盖率评价的是测试代码的质量,并不是产品代码的质量代码覆盖率是一种白盒测试,因为测试覆盖率是评价产品代码类内部的指标,而不是评价系统接口或规约。测试覆盖率尤其用于评价测试代码是否已经覆盖了...
  • 做过一段状态栏颜色适配,纯色的基本在style直接设置就可以了, 不过最近效果图有一种效果要求 是在状态栏部分也显示内容部分, 像下面这样
  • 白盒测试中常见的覆盖有六种:语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖和路径覆盖。下面我们就分别看看这几种不同的覆盖究竟是什么鬼。 一、语句覆盖(Statement Coverage) 语句覆盖,顾名思义就是...
  • Jacoco增量代码覆盖

    千次阅读 2020-10-27 18:56:18
    jacoco增量代码覆盖率 作者:兰绿,荣荣 文章结构 背景 Jacoco简介 Jacoco 增量代码覆盖率设计方案 Jacoco增量代码覆盖率+持续交付 总结 一、背景 需求测试过程中,测试主要依靠需求及一些测试经验来主观保证质量...
  • 条件覆盖,路径覆盖,语句覆盖

    千次阅读 2020-05-28 10:43:48
    语句覆盖是指选择足够的测试用例,使得运行这些测试用例时,被测程序的每一个语句至少执行一次,其覆盖标准无法发现判定中逻辑运算的错误;判定覆盖是指选择足够的测试用例,使得运行这些测试用例时,每个判定的所有...
  • 最近在复习软件测试的考试,每次...根据覆盖目标的不同和覆盖源程序语句的详尽程度,逻辑覆盖又可分为:语句覆盖,判定覆盖,条件覆盖,条件/判定覆盖,条件组合覆盖,路径覆盖 这里以一个题目引入: if (a&gt;...
  • 覆盖率的沧海变化前言一、栅格数据转为灰度图二、灰度图转为伪彩色图三、合成为gif写在最后 前言 昨天学弟给了我一个数据包“我国NDVI的栅格数据”(即归一化植被指数),需要把陕西省的数据批量裁剪出来: 于是,...
  • 浅谈代码覆盖

    千次阅读 2020-03-18 10:56:04
    Martin Fowler(重构那本书的作者)曾经写过一篇博客来讨论这个问题,他指出:把测试覆盖作为质量目标没有任何意义,而我们应该把它作为一种发现未被测试覆盖的代码的手段。 代码覆盖率的意义 分析未覆盖部分的...
  • 六种覆盖标准发现错误的能力呈由弱到强的变化 语句覆盖:每条语句至少执行一次。 判定覆盖:每个判定的每个分支至少执行一次。 (包含语句覆盖,每个判断T、F各一次) 条件覆盖:每个判定的每个条件应取到各种...
  • 最近测试的同学反馈一个问题,他在测试完项目以后查看覆盖率的结果,发现有个逻辑明明已经覆盖了,但是覆盖率的报告里面显示的却是没有覆盖。 以下就是源码的内容,并且现场演示了接口返回库存不足的逻辑。 看到这...
  • 代码覆盖率检测正是帮助开发、测试同学提前发现问题,保证代码质量的好帮手。 对于开发者而言,代码覆盖率可以反馈两方面信息: 自测的充分程度。 代码设计的冗余程度。 尽管代码覆盖率对代码质量有着上述好处,但...
  • 文章转自:https://blog.csdn.net/virus2014/article/details/51217026...  1语句覆盖 使所有的判断语句都能执行一次的条件案例,例如有两个if语句,那么就至少需要两个测试用例   2判定覆盖(分支覆盖) ...
  • 全球最新的土地覆盖数据在这里!

    千次阅读 2020-09-21 16:57:15
    30米全球地表覆盖数据GlobeLand30是中国研制的30米空间分辨率全球地表覆盖数据,2014年发布GlobeLand30 2000和2010版。自然资源部于2017年启动对该数据的更新,目前,GlobeLand30 2020版已完成。 1数学基础 ...
  • 谈谈测试覆盖

    千次阅读 2019-10-24 14:06:27
    以前面试的时候,两次被问到同一个问题,“你是如何计算测试覆盖率的?”,但每次回答都不好,直到最近看了一些文章,有所感悟,总结如下: 1 定义 测试覆盖率通常被用来衡量测试的充分性和完整性。从广义角度讲,...
  • 测试覆盖率统计工具 概述: 要定义“测试覆盖率”,我们必须谈论以下主题: 测试覆盖的目的。 不同类型的测试覆盖率标准。 测试覆盖率指标 单元测试范围 测试覆盖率工具 测试覆盖范围的优缺点。 ...
  • 逻辑覆盖测试是通过对程序逻辑结构的遍历实现...从覆盖源代码的不同程度可以分为以下六个标准:语句覆盖、判定覆盖(又称为分支覆盖)、条件覆盖、判定-条件覆盖(又称为分支-条件覆盖)、条件组合覆盖和路径覆盖...
  • 为以下流程图所示的程序段设计一组测试用例,要求分别满足语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖和路径覆盖。 语句覆盖:每条语句至少执行一次,即每个可执行语句都执行一次。 判定覆盖:每个...
  • 语句覆盖 - 设计一套测试 让被测对象中所有语句得到测试覆盖 判定覆盖 - 设计一套测试 让被测对象中所有判定得到测试覆盖 条件覆盖 - 设计一套测试 让被测对象中所有条件得到测试覆盖 路径覆盖 - 设计一套测试 让被...
  • 本文内容基于覆盖率驱动的验证技术(CDV):代码覆盖率:断言覆盖率定义功能覆盖率模型covergroup解释功能覆盖率的采样事件定义覆盖点:bins定义覆盖点:条件覆盖定义覆盖点:状态跳转覆盖定义覆盖点:交叉覆盖生成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,037,387
精华内容 814,954
关键字:

覆盖