白盒测试之循环语句覆盖法

最新推荐文章于 2024-05-09 16:55:40 发布
最新推荐文章于 2024-05-09 16:55:40 发布
阅读量1.1k 收藏 19
点赞数 42
分类专栏： 测试 文章标签： 软件工程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haobabiu/article/details/137860877
版权

白盒测试之循环语句覆盖法（蓝桥课学习笔记）

1、简单循环

实验介绍

循环是反复运行同一段代码的语法结构，是代码中常见的一种结构。在白盒测试中，循环结构的测试也是我们需要掌握的内容。循环结构测试主要的侧重点是验证循环结构的有效性，一般可以结合条件覆盖、基本路径覆盖以及黑盒测试方法中的等价类、边界值等方法来设计测试用例。

在白盒测试中循环可以分为四种：简单循环、串接循环、嵌套循环和非结构化循环，其中非结构化循环的可读性、可维护性和可测试性都很差，一般建议重新设计并调整为结构化的程序代码后再进行测试。

简单循环是最简单的循环，即只有一个循环且没有嵌套，例如，一个 while 循环、一个do-while 循环、一个 for 循环。下图是两种简单循环的示意图：

图片描述

本实验主要通过一个实例介绍简单循环结构的测试方法。注：实验过程中需要使用 eclipse 软件，请读者实验前在电脑上下载并安装好 eclipse 软件。

知识点
  • 简单循环测试

实验内容

本次实验的测试对象是求任意一个10以内整数的阶乘，具体需求为：输入1 ~ 10的任意整数，输出该数字的阶乘数；输入不为 1 ~ 10 的整数时提示“请输入 1 ~ 10 的整数！

下面是一段计算数字阶乘的 Java 代码，这段代码只有一个循环且没有嵌套，属于一个简单循环，下面我们就以计算阶乘为例介绍简单循环的测试方法。

public static int getFactorial(Integer num) {  
      int result = 0; 
      if (num >= 1 && num <= 10){
          result = 1; 
          int i = 1;
          while (i < num){
            result = result * i; 
            i++;
         }
           System.out.println(num + "的阶乘为：" + result);       
       }
      else{
          System.out.println("请输入1~10的整数！"); 
      }   
        return result;
    }

实验步骤

第 1 步：分析源代码，画出流程图。

这个步骤主要是帮助我们理清思路，为后面的测试用例设计打下基础。如果代码比较简单，或是对测试用例设计方法比较熟练以后，可以简化流程图，也可以省略这一步，直接进行测试用例设计。本例的参考流程图如下：

图片描述

第 2 步：设计测试用例。

循环测试的侧重点是测试循环结构的有效性，主要考虑循环的边界和运行界限执行循环体的情况，所以设计简单循环结构的测试用例主要需要考虑循环变量的初始值、增量、最大值，以及边界取值的情况下代码处理是否正确。我们可以结合黑盒测试用例设计方法中的等价类边界值的方法来设计测试用例，即”如果输入/输出条件规定了值的个数，则用最大个数、最小个数、比最小个数少 1 ，比最大个数多 1 的值作为测试数据“。一般来说，简单循环的测试用例需要考虑下列几种情况（设最大循环次数为 n ）：

（1）循环 0 次：测试跳过整个循环的场景；

（2）循环 1 次：目的是检查循环的初始值是否正确；

（3）循环 2 次：目的是检查多次循环是否正确；

（4）循环 m 次（其中 2 < m < n - 1）：目的是检查多次循环是否正确，这里我们也可以用等价类的思想来理解，即：可以把大于 2 次、小于 n - 1 次看成是一个等价类，m 可以是这个范围中的任意一个值，根据等价类的思想，如果这个范围中的任意一个值是不会发现程序的问题，那么，我们可以认为这个等价类中所有的值都不会发现程序的问题；

（5）循环 n - 1 次：目的是检查边界值是否正确；

（6）循环 n 次：目的是检查边界值是否正确；

（7）循环 n + 1 次：目的是检查边界值是否正确。这里读者可能会有疑问，一个循环的最大循环次数是 n ，我们要怎么让它循环 n + 1 次呢？这不是一个伪命题吗？通过对边界值方法的理解，我们可以知道，等于、大于、小于边界值的地方是最容易出现 bug 的，如，“差 1 错”，即不正确的多循环或者少循环了一次。在循环结构的测试中设计循环 n + 1次的测试用例，就是为了检查代码是否会出现多循环一次的错误。在实际的测试过程中，我们可以通过分析代码结构决定是否能设计出循环 n + 1次的测试用例。

在本例中，根据以上原则我们可以设计如下测试用例数据：

循环次数0 次1 次2 次m 次n-1 次n 次n+1 次
测试用例（ num 的值）012591011

转化为测试用例，如下表所示：

测试用例编号输入预期输出
testcase_010result=0，输出：请输入1~10的整数！
testcase_021result=1，输出：1的阶乘是1
testcase_032result=2，输出：2的阶乘是2
testcase_045result=120，输出：5的阶乘是120
testcase_059result=362880，输出：9的阶乘是362880
testcase_0610result=3628800，输出：10的阶乘是3628800
testcase_0711result=0，输出：请输入1~10的整数！

第 3 步：执行测试用例。

白盒测试用例一般使用专门的测试工具（如：Junit）来执行，使用这些工具可以非常方便的编写测试用例、判断测试用例执行结果是否正确。在没有学习测试工具之前，我们先使用调用被测函数的方法来执行测试用例。具体执行方法为：

1）依次使用测试用例的输入值调用被测对象；

2）比较被测对象的实际返回值与测试用例的“预期输出”是否一致：如果一致，则测试用例执行通过；如果不一致，则测试用例执行失败。

具体的测试代码如下：

package test;

public class simpleTest {
    // 执行测试用例
    public static void main(String[] args) {
        // 执行用例 testcase_01
        if(getFactorial(0) == 0){
            System.out.println("testcase_01执行通过\n");
        }
        else{
            System.out.println("预期输出为：0 ");
            System.out.println("testcase_01执行失败\n");
        }
        
        // 执行用例 testcase_02
        if(getFactorial(1) == 1){
            System.out.println("testcase_02执行通过\n");
        }
        else {
            System.out.println("预期输出为：1 ");
            System.out.println("testcase_02执行失败\n");
        }
        
        // 执行用例 testcase_03
        if(getFactorial(2) == 2){
            System.out.println("testcase_03执行通过\n");
        }
        else{
            System.out.println("预期输出为：2 ");
            System.out.println("testcase_03执行失败\n");
        }
        
        // 执行用例 testcase_04
        if(getFactorial(5) == 120){
            System.out.println("testcase_04执行通过\n");
        }
        else{
            System.out.println("预期输出为：120 ");
            System.out.println("testcase_04执行失败\n");
        }
        
        // 执行用例testcase_05
        if(getFactorial(9) == 362880){
            System.out.println("testcase_05执行通过\n");
        }
        else{
            System.out.println("预期输出为：362880 ");
            System.out.println("testcase_05执行失败\n");
        }
        
        // 执行用例testcase_06
        if(getFactorial(10) == 3628800){
            System.out.println("testcase_06执行通过\n");
        }
        else{
            System.out.println("预期输出为：3628800 ");
            System.out.println("testcase_06执行失败\n");
        }
        
        // 执行用例 testcase_07
        if(getFactorial(11) == 0){
            System.out.println("testcase_07执行通过\n");
        }
        else{
            System.out.println("testcase_07执行失败\n");
        }
   }

以上代码在 eclipse 中执行的结果如下图所示：

图片描述

从上图可以看出，七个测试用例有四个是执行失败的。分析这四个用例的实际输出和预期输出，我们可以发现：实际输出和预期输出相比，少乘了一个该数字本身，例如，测试用例 testcase_03 “ 2 的阶乘”的实际输出是 1 ，预期输出是 2 ，少乘了 2 ；测试用例 testcase_04 “ 5 的阶乘”的实际输出是 24 ，预期输出是 120 ，少乘了 5 。由此我们可以推断出，计算阶乘的 while 循环少循环了一次，即 while (i < num) 应该改为 while (i <= num) 。 。 修改代码后重新执行测试用例进行回归测试的结果如下，所有用例都执行通过：

图片描述

实验总结

简单循环的测试重点是验证循环结构的有效性，主要考虑循环的边界和运行界限执行循环体的情况。对于最多为 n 次的简单循环，一般需要设计跳过循环、循环 1 次、2 次，m 次（2<m<n-1）、n - 1 次、n 次、n + 1 次的测试用例，重点测试循环变量的初值、最大值、增量以及退出循环的情况。如果循环的最大循环次数不确定，一般设计跳过循环、循环 1 次、2 次，m 次的测试用例即可。

2、嵌套循环

实验介绍

嵌套循环是指一个循环语句的循环体内含有其他的循环语句的语法结构，while、for 等循环语句都可以进行嵌套。最常见的嵌套循环是 for 循环中嵌套 for 循环。嵌套循环执行时，外层循环每执行一次内层循环会执行多次，循环的总次数等于外层循环次数与内层循环次数的积。下面是一个嵌套循环的示意图：

图片描述

本实验主要通过一个实例介绍嵌套循环结构的测试方法。注：实验过程中需要使用 eclipse 软件，请读者实验前在电脑上下载并安装好 eclipse 软件。

知识点
  • 嵌套循环测试

实验内容

冒泡排序是大家都比较熟悉的一种排序算法，在算法中有两个 for 循环，这也是一个典型的嵌套循环的例子。下面是 Java 编写的一段冒泡排序的代码，本实验我们就以这段冒泡排序代码为例，介绍如何测试嵌套循环结构。

//冒泡排序
public static int[] bubble_sort(int[] numbers){  
    for (int i = 0; i < numbers.length - 1;i++ ){
        boolean flag = false; 
        for (int j = 0;j < numbers.length - 1 - i;j++){
            if (numbers[j] > numbers[j+1]){
                int temp = 0;
                temp = numbers[j];
                numbers[j] = numbers[j+1];
                numbers[j+1] = temp;
                flag = true;
            }
        }
        if (flag == false){
            break;
        }
    }
    return numbers;
}

实验步骤

第 1 步：分析源代码，画出流程图。

从上面的代码可以看出，冒泡排序有两个 for 循环，外层循环根据数组的长度控制外层循环次数，内层循环则是将大数下沉，实现冒泡的过程。本例的参考流程图如下：

图片描述

第 2 步：设计测试用例。

嵌套循环和简单循环的测试侧重点是相同的，都是侧重于验证循环结构的有效性。但是我们也不能直接将简单循环的测试方法应用于嵌套循环，因为如果按照简单循环的思路，测试用例的数量将随着嵌套层次的增加而成几何级增长，让测试变得非常困难。那么，怎样设计测试用例才能让嵌套循环的测试既能尽可能覆盖全面、又能减少测试用例数量呢？我们可以从以下几方面进行考虑：

1）按简单循环的方法对最内层循环进行测试，其他循环次数设置为最小值；

2）由内向外逐步对每一层循环进行测试，直到所有各层循环都测试完成。测试时将当前循环的所有外层循环的循环次数设置为最小值，所有内层循环的循环次数设置为典型值；

3）对各层循环同时取最小循环次数进行测试，如果有最大次数，再同时取最大循环次数进行测试。

下面我们根据这几个测试用例设计的原则来设计本实验中冒泡排序的测试用例：

1）设计内层循环的测试用例：用简单循环的方法对下面的最内层循环进行测试，将外层循环的循环次数设置为最小值 。

for (int j = 0;j < numbers.length-1-i;j++){
    if (numbers[j] > numbers[j+1]){
            int temp = 0;
            temp = numbers[j];
            numbers[j] = numbers[j+1];
            numbers[j+1] = temp;
            flag = true;
            }
        }

在本例中，根据以上原则我们可以对内层循环设计如下测试用例：

跳过循环：只有一个数时，内层循环不会执行，如：{3}

循环 1 次：当数组中有两个数字时，内层循环会循环一次，如：{21,2}

循环 2 次：当数组中有三个数字，且是按从小到大的顺序排列时，外层循环只会循环 1 次，为该层循环的最小值，而内层循环会循环两次，如：{1,2,21}

循环 m 次：根据简单循环测试用例设计的原则，如果循环没有最大循环次数，我们可以选择任意一个大于 2 的循环次数设计一个测试用例测试多次循环是否正确。这里我们设计一个循环 5 次的测试用例 ，通过分析代码的循环结构，我们可以知道，当传入6个数字，且数字是按从小到大的顺序排列时，外层循环只循环 1 次，内层循环会循环 5 次，如：{1,4,7,11,23,65}

2）设计外层循环的测试用例：

跳过循环：只有一个数时，外层循环不会执行，如：{3}

循环 1 次：当传入的数字都是按从小到大的顺序排列时，外层循环只会循环一次，如：{1,3,5,9}

循环 2 次：当数组中的数字需要交换一次位置时，外层循环会循环两次，如：{3,9,5,48,90}

循环 m 次：可以选择任意一个大于 2 的循环次数设计一个测试用例测试外层多次循环是否正确，如：{76,2,22,59,5,155,1,90,18}

3）对各层循环同时取最小循环次数或最大循环次数进行测试。在本例中内层和外层循环最小次数 1 都已有相关用例覆盖，这里不再重复设计。

综上所述，去重后冒泡排序的测试用例如下：

测试用例编号输入预期输出
testcase_01{3}{3}
testcase_02{21,2}{2,21}
testcase_03{1,2,21}{1,2,21}
testcase_04{1,4,7,11,23,65}{1,4,7,11,23,65}
testcase_05{1,3,5,9}{1,3,5,9}
testcase_06{3,9,5,48,90}{3,5,9,48,90}
testcase_07{76,2,22,59,5,155,1,90,18}{1,2,5,18,22,76,90}

第 3 步：执行测试用例。

在这里还是使用调用被测函数的方法来执行测试用例，在简单循环中我们使用的是单个用例输入测试数据，判断预期结果的方法，这里换一种更简洁的方式，把所有测试用例输入和预期输出数据都初始化以后一起执行用例、判断实际执行结果与预期输出是否一致。具体的测试代码如下：

package test;

import java.util.Arrays;

public class NestingloopTest {
    // 执行测试用例
    public static void main(String[] args){
        //初始化测试用例输入数据
        int[][] input_testcase = {
                {3},
                {21,2},
                {1,2,21},
                {1,4,7,11,23,65},
                {1,3,5,9},
                {3,9,5,48,90},
                {76,2,22,59,5,155,1,90,18}
        };
        //初始化测试用例预期结果
        int[][] expect_result = {
                {3},
                {2,21},
                {1,2,21},
                {1,4,7,11,23,65},
                {1,3,5,9},
                {3,5,9,48,90},
                {1,2,5,18,22,59,76,90,155}
        };
        
        //执行测试用例
        for (int i = 0; i < 7; i++){
            int[] execute_result = bubble_sort(input_testcase[i]);
            //比较的执行结果与测试用例的预期输出是否一致：如果一致则用例执行通过，如果不一致则用例执行失败
            Boolean test_result = Arrays.equals(execute_result, expect_result[i]);
            if (test_result){
                System.out.println("testcase_0" + (i + 1) + "执行通过！\n");
            }
            else{
                System.out.println("预期结果为：" + Arrays.toString(expect_result[i]));
                System.out.println("实际结果为：" + Arrays.toString(execute_result));
                System.out.println("testcase_0" + (i + 1) + "执行失败！\n");
            }    
        }    
    }
    
//冒泡排序
public static int[] bubble_sort(int[] numbers){  
    for (int i = 0; i < numbers.length - 1; i++ ){
        boolean flag = false;
        for (int j = 0; j < numbers.length - i - 1; j++){
            if (numbers[j] > numbers[j+1]){
                int temp = 0;
                temp = numbers[j];
                numbers[j] = numbers[j+1];
                numbers[j+1] = temp;
                flag = true;
            }
        }
        if (flag == false){
            break;
        }
    }
    return numbers;    
}
}

以上代码在 Eclipse 中执行的结果如下图所示，从图中可以看出所有的测试用例都执行通过了：

图片描述

实验总结

嵌套循环结构的测试侧重点与简单循环相同，都是侧重于验证循环的有效性，不同点在于嵌套循环结构设计测试用例时需考虑用尽可能少的用例覆盖更全面的场景，降低测试成本，提高测试效率。

3、串接循环

实验介绍

串接循环是指两个或多个循环连接在一起的循环结构，也称连锁循环。串接循环分为两种：第一种是各个循环体彼此独立、相互之间没有关联关系，这种循环我们可以使用简单循环的方法，依次对每个独立的循环体进行测试；第二种串接循环是各个循环体之间有关联关系，第二个循环的输入来自于第一个循环的输出，对于这种串接循环，我们可以考虑使用嵌套循环的测试方法来进行测试。

下图是串接循环的示意图：

图片描述

因为第一种串接循环可以完全使用简单循环的方法来测试，这里不再赘述，本实验主要使用一个实例介绍各个循环体有关联关系的串接循环的测试方法。注：实验过程中需要使用 eclipse 软件，请读者实验前在电脑上下载并安装好 eclipse 软件。

知识点
  • 串接循环测试

实验内容

下面是一段将数组中的最大数分解质因数的代码，这是一个串接循环的例子，本实验我们就以这段代码为例，介绍如何测试串接循环结构。

    public static String test(int[] numbers){  
        int max_number = 0;
        int factor = 2;
        String result = "";
        //求数据组中的最大值
        for (int i = 0; i < numbers.length - 1; i++){
            if (max_number < numbers[i]){
                max_number = numbers[i];
            }
        }
        //将最大值分解质因数
        int tmp = max_number;
        while(factor <= tmp){
            if(factor == tmp){
                result = result + Integer.toString(factor);
                break;
            }
            else if(tmp % factor == 0){
                result = result + factor + "*"; 
                tmp = tmp / factor;
            }
            else{
                factor++;
            }    
        }    
        System.out.println(max_number + "分解质因数的结果为：" + result);
        return result;    
    }

实验步骤

第 1 步：分析代码结构。

通过观察我们可以发现：这段代码中一共有两个循环，第一个 for 循环的输出是第二个 while 循环的输入，也就是上面所说的第二种串接循环，即各个循环体之间有关联关系的串接循环。本例的流程图与实验介绍中典型的串接循环流程图类似，所以此处不再重复。

第 2 步：设计测试用例。

串接循环与嵌套循环、简单循环的测试侧重点一样，也是侧重于验证循环结构的有效性。对于循环体之间有关联关系的串接循环，我们可以使用嵌套循环的测试方法来进行测试，即：

1）按简单循环的方法对下层循环进行测试，其他循环次数设置为最小值；

2）由下至上逐步对每一层循环进行测试，直到所有循环都测试完成。测试时将当前循环的所有上层循环的循环次数设置为最小值，所有下层循环的循环次数设置为典型值；

3）对各层循环同时取最小循环次数进行测试，如果有最大次数，再同时取最大循环次数进行测试。

下面我们根据这几个原则来设计测试用例：

1）设计第一个 for 循环的测试用例：

//求数据组中的最大值
for (int i = 0; i < numbers.length - 1; i++){
        if (max_number < numbers[i]){
            max_number = numbers[i];
        }
    }

用简单循环的方法对下面的最内层循环进行测试，将外层循环的循环次数设置为最小值 ，可以设计如下测试用例：

跳过循环：当传入的数组为空时会跳过 for 循环，即：{}

循环 1 次：当传入的数组中只有一个数字时，for 循环只会循环一次，如：{6}

循环 2 次：当传入的数组中有两个数字时 for 循环会循环两次，如：{75,11}

循环 m 次：因为这个循环没有最大循环次数，所以可以选择任意一个大于 2 的循环次数设计一个测试用例测试多次循环是否正确。这里我们设计一个循环 6 次的测试用例 ，如：{20,6,90,21,45,76}

2）设计第二个 while 循环的测试用例：

while(factor <= tmp){
    if(factor == tmp){
        result = result + Integer.toString(factor);
        break;
    }
    else if(tmp % factor == 0){
        result = result + factor + "*"; 
        tmp = tmp / factor;
    }
    else{
        factor++;
    }    
}

跳过循环：当传入的数组为空或传入的数组中只有数字 1 时，会跳过 while 循环，因为测试 for 循环的时候我们已经设计了数组为空的测试用例，所以这里我们选择数组中只有数字 1 的用例，即：{1}

循环 1 次：当数组中的最大值为 2 时，while 循环只会执行 1 次，如：{2,1}

循环 2 次：当数组中的最大值为 3 或 4 时，while 循环会执行 2 次，如：{4,1,3,2}

循环 m 次：可以选择任意一个大于 2 的循环次数设计一个测试用例测试 while 循环是否正确，如：{27,5,50,2,100,11,21}

3）对各个循环同时取最小循环次数或最大循环次数进行测试。在本例中两个循环的最小次数 1 都已有相关用例覆盖，这里不再重复设计。

综上所述，测试用例如下：

测试用例编号输入预期输出
testcase_01{}空
testcase_02{6}2 * 3
testcase_03{75,11}3 * 5 * 5
testcase_04{20,6,90,21,45,76}2 * 3 * 3 * 5
testcase_05{1}空
testcase_06{2,1}2
testcase_07{4,1,3,2}2 * 2
testcase_08{27,5,50,2,100,11,21}2 * 2 * 5 * 5

第 3 步：执行测试用例。

调用被测函数执行测试用例，判断实际执行结果与预期输出是否一致。具体的测试代码如下：

package test;

public class CascadeCycleTest {
    // 执行测试用例
    public static void main(String[] args){//初始化测试用例输入数据
        int[][] input_testcase = {
                {},
                {6},
                {75,11},
                {20,6,90,21,45,76},
                {1},
                {2,1},
                {4,1,3,2},
                {27,5,50,2,100,11,21},
        };
        //初始化测试用例预期结果
        String[] expect_result = {
                "",
                "2*3",
                "3*5*5",
                "2*3*3*5",
                "",
                "2",
                "2*2",
                "2*2*5*5",
        };
        
        //执行测试用例
        for (int i = 0; i < 8; i++){
            String execute_result = test(input_testcase[i]);
            //比较的执行结果与测试用例的预期输出是否一致：如果一致则用例执行通过，如果不一致则用例执行失败
            Boolean test_result = execute_result.equals(expect_result[i]);
            if (test_result){
                System.out.println("testcase_0" + (i + 1) + "执行通过！\n");
            }
            else{
                System.out.println("预期结果为：" + expect_result[i+1]);
                System.out.println("实际结果为：" + execute_result);
                System.out.println("testcase_0" + (i + 1) + "执行失败！\n");
            }    
        }    
    }
    
    public static String test(int[] numbers){  
        int max_number = 0;
        int factor = 2;
        String result = "";
        //求数据组中的最大值
        for (int i = 0; i < numbers.length - 1; i++){
            if (max_number < numbers[i]){
                max_number = numbers[i];
            }
        }
        //将最大值分解质因数
        int tmp = max_number;
        while(factor <= tmp){
            if(factor == tmp){
                result = result + Integer.toString(factor);
                break;
            }
            else if(tmp % factor == 0){
                result = result + factor + "*"; 
                tmp = tmp / factor;
            }
            else{
                factor++;
            }    
        }    
        System.out.println(max_number + "分解质因数的结果为：" + result);
        return result;    
    }    
}

以上代码在 Eclipse 中执行的结果如下图所示：

图片描述

从上图中可以看出，测试用例 testcase_02 的执行结果为失败。分析该用例输出的实际结果，可以发现待分解质因数的数为空，也就是第一个循环（数据组中的最大值）没有正确地计算出数组 {6} 中的最大值。通过分析第一个循环的代码，我们可以发现问题出在 for 循环的最大循环次数，代码中 for 的最大循环次数是数组的长度减 1 ，导致只有一个数字的数组无法计算出最大值。

图片描述

根据以上分析，我们可以将这段代码修改如下：

//求数据组中的最大值
for (int i = 0; i < numbers.length; i++){
    if (max_number < numbers[i]){
        max_number = numbers[i];
    }
}

修改代码后再次执行测试用例进行回归测试的结果如下：

图片描述

实验总结

各个循环体彼此独立的串接循环可以使用简单循环的方法单独测试每一个循环，循环体之间有关联关系的串接循环则可以考虑使用嵌套循环的测试方法来进行测试。

大猪猪吃虎虎
关注
  • 42
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
白盒测试之基本路径测试法
03-23
白盒测试的测试方法有代码检查法、静态结构分析法、静态质量度量法、逻辑覆盖法、基本路径测试法、域测试、符号测试、Z路径覆盖、程序变异。其中运用最为广泛的是基本 　白盒测试的测试方法有代码检查法、静态结构...
单元测试---简单循环覆盖法
chuanchuankk的博客
04-12 487
请使用的标准要求，对被测源代码 Utils 类中的 stringStyle 方法进行设计单元测试用例。并在 UtilsTest 类中完成单元测试代码。
白盒测试之语句覆盖、判定覆盖、条件覆盖等
Learning_Well的博客
11-07 4842
指的是设计足够多的测试用例，使判定语句中每个条件的所有可能至少出现一次，并且每个判定语句本身的判定结果也至少出现一次，它与判定-条件覆盖的差别是，条件组合覆盖不是简单地要求每个条件都出现“真”与“假”两种结果，而是要求让这些结果的所有可能组合都至少出现一次。：白盒测试是一种测试用例设计方法；其中逻辑覆盖包括语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、条件组合覆盖和修改条件判定覆盖。：要求设计足够多的测试用例，使得判定语句中所有条件的可能取值至少出现一次，同时，所有判定语句的可能结果也至少出现一次。
详解软件测试中白盒测试基本概念及四种白盒测试方法以及六种逻辑覆盖法（语句覆盖、判定覆盖、条件覆盖、判定条件覆盖、条件组合覆盖、路径覆盖）
热门推荐
萌面超人的博客
12-13 7万+
在这篇文章中，我们将讲解白盒测试的基本概念，以及四大常用的白盒测试方法。
白盒测试之语句分支条件覆盖
qq_42744046的博客
04-26 5048
白盒测试之语句分支条件覆盖 本文预览 语句覆盖 基本概念：这是最常用也是最常见的一种覆盖方式，就是度量被测代码中每个可执行语句是否被执行到了。不包括注释、空行。 public static void main(String[] args) { 1 Scanner scanner = new Scanner(System.in); 2 while (scanner....
白盒测试之逻辑覆盖法
weixin_44772874的博客
08-01 2462
逻辑覆盖法 逻辑覆盖是以程序内部的逻辑结构为基础的设计测试用例的技术。 根据覆盖目标的不同和覆盖源程序语句的详尽程度，逻辑覆盖又可分为： 语句覆盖 判定覆盖 条件覆盖 判定/条件覆盖 条件组合覆盖 修正判定条件覆盖 点覆盖 边覆盖 路径覆盖 几种逻辑覆盖标准发现错误的能力呈由弱至强的变化。 语句覆盖 语句覆盖是指选择足够的测试用例，使得运行这些测试用例时，被测程序的每一个语句至少执行一次，其覆盖标准无法发现判定中逻辑运算的错误。 被测试代码： int foo(int a, int b){ return
软考高级：白盒测试用例（语句覆盖、判断覆盖、条件组合覆盖、条件判定组合覆盖）概念和例题
明明如月的技术博客
03-07 1425
明明如月学长， CSDN 博客专家，大厂高级 Java 工程师，《性能优化方法论》作者、《解锁大厂思维：剖析《阿里巴巴Java开发手册》》、《再学经典：《Effective Java》独家解析》专栏作者。
白盒测试之语句覆盖
我的专栏
09-19 3310
白盒测试作为测试人员常用的一种测试方法，越来越受到测试工程师的重视。白盒测试并不是简单的按照代码设计用例，而是需要根据不同的测试需求，结合不同的测试对象，使用适合的方法进行测试。因为对于不同复杂度的代码逻辑，可以衍生出许多种执行路径，只有适当的测试方法，才能帮助我们从代码的迷雾森林中找到正确的方向。本文介绍六种白盒子测试方法：语句覆盖、判定覆盖、条件覆盖、判定条件覆盖、条件组合覆盖、路径覆盖。
软件测试语句覆盖代码,白盒测试：语句覆盖率测试
weixin_42511053的博客
07-22 976
语句覆盖率是广泛使用的软件测试之一。它经过白盒测试。语句覆盖技术用于设计白盒测试用例。该技术涉及至少一次执行源代码的所有语句。它用于计算源代码中存在的全部语句中源代码中已执行的语句总数。语句覆盖率基于代码的结构得出白盒测试过程中的测试用例场景。 在白盒测试中, 测试人员专注于内部源代码和代码流程图或流程图的工作。通常, 在内部源代码中, 有各种各样的元素, 例如运算符, 方法, 数组, 循环, 控...
白盒测试-覆盖测试（六种覆盖方法）
MarryLinDa的博客
03-20 2万+
白盒测试-覆盖测试 测试覆盖率：用于确定测试所执行到的覆盖项的百分比。其中的覆盖项是指作为测试基础的一个入口或属性，比如语句、分支、条件等。 结构覆盖率包括语句覆盖率、分支覆盖率、循环覆盖率、路径覆盖率等。 测试覆盖中需要遵循的两条准则：ESTCA准则、LCSAJ准则。
浅析白盒测试中的逻辑覆盖测试
01-27
在白盒测试中，逻辑覆盖测试是使用较多的方法。按照其对测试的有效程度，又将其划分为由弱到强的6种：语句覆盖、判定覆盖、条件覆盖、判定-条件覆盖、条件组合覆盖、路径覆盖。在这里，不深究各个覆盖的优缺点，仅仅...
白盒测试中的语句覆盖
12-20
白盒测试中的语句测试，虽然语句测试最简单，不过他是学好逻辑覆盖的基础
白盒测试及用例设计白盒测试法的覆盖标准
01-05
白盒测试，白盒测试及用例设计，白盒测试法的覆盖标准有逻辑覆盖、循环覆盖和基本路径测试。其中逻辑覆盖包括语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、条件组合覆盖和路径覆盖、
白盒测试wbt02逻辑覆盖与循环覆盖
04-15
对白盒测试的逻辑覆盖与循环覆盖进行全面的讲解，测试设计方法。
软件工程复习之软件定义时期
最新发布
qq_63668923的博客
05-09 319
答：软件是程序，数据和文档的集合。程序是完成指定功能的计算机可执行的指令序列。数据是程序进行信息处理的数据结构。文档是开发，使用，维护的图文资料。答：软件危机是指在计算机软件开发和维护过程中遇到的严重问题。问题主要分为两方面：如何开发软件以满足日益增长的用户需求；如何维护数量不断膨胀的已有软件。答：在软件生命周期全过程中使用的一整套技术方法的集合，包括：方法，工具和过程。分为传统方法学和面向对象方法学。
【软件工程】需求分析
qq_72680384的博客
05-02 1911
软件工程，UML，需求分析
软件开发标准流程与软件工程基本理论
minimonkey850122的博客
05-02 489
确定实现该软件系统的具体实现方案，确定具体实现的技术：编程语言、数据库、缓存系统、前端实现技术（WinForm或WPF或页面：前端样式、前端框架、前端脚本技术、前端样式、页面设计）、通信技术（前端和后台的交互：前后端分离、单应用系统，微服务等）；生产环境部署：软件项目在用户生产环境部署，用户试运行，发现bug及缺陷、用户基于需求分析提出的问题，修复bug、修正缺陷、解决用户提出的问题完善软件项目系统。根据详细设计文档、需求分析文档，测试编码实现的软件项目，提交软件Bug并修正、测试，提交测试报告。
软件工程毕业设计选题100例
HUXINY的博客
05-02 1209
学长搜集分享最新的软件工程业专业毕设选题，难度适中，适合作为毕业设计，大家参考。相对容易工作量达标题目新颖。
白盒测试循环语句覆盖
04-02
白盒测试是一种测试方法，它关注内部结构和逻辑的测试。循环语句覆盖是白盒测试中的一种覆盖准则，用于确保循环的各个部分都被测试到。 循环语句覆盖包括以下几个方面： 1. 循环未执行：测试用例中不满足循环条件，直接跳过循环体。 2. 循环执行一次：测试用例中满足循环条件，循环体执行一次。 3. 循环执行多次：测试用例中满足循环条件，循环体执行多次。 4. 循环退出：测试用例中满足循环条件，但在某个时刻退出循环。 通过对以上几个方面进行测试，可以尽可能地覆盖循环语句的各种情况，提高代码的可靠性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大猪猪吃虎虎

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值