[变异测试] Major使用教程

已于 2022-12-09 10:18:05 修改
阅读量1.5k 收藏 11
点赞数 2
分类专栏： 工具 文章标签： linux java 功能测试 测试工具 单元测试
于 2022-11-07 22:52:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52883908/article/details/127721055
版权

[变异测试] Major使用教程

Major官网
Major文档
Major论文
Major下载

从官网下载Major的压缩包，1.3.0版本的Major支持JDK8。

使用Major做变异测试需要使用Major自带的javac，可以在bash文件中配置

export MAJOR_DIR=XXX
export PATH=$PATH:$MAJOR_DIR

也可以通过如下方式调用：

# 输入
Major路径/bin/javac -version
# 结果
javac 1.7.0-Major-v1.3.5

Major项目的结构：
在这里插入图片描述

1. MML文件

要想做变异测试，首先需要定义变异算子。在Major中，.mml文件负责定义使用的变异算子，bin/mmlc负责变异变异算子文件。

可以直接使用Major默认提供的.mml文件
在这里插入图片描述
拿tutorial.mml举例子，该文件中开启了STD、COR与ROR三个变异算子。允许变异的对象是
triangle.Triangle类中的classify(int,int,int)方法（一个项目可能有多个类与多个方法，因此我们可以指定需要变异的对象）。

targetOp{
    // Define the replacements for ROR
    BIN(>)->{>=,!=,FALSE};
    BIN(<)->{<=,!=,FALSE};
    BIN(>=)->{>,==,TRUE};
    BIN(<=)->{<,==,TRUE};
    BIN(==)->{<=,>=,FALSE,LHS,RHS};
    BIN(!=)->{<,>,TRUE,LHS,RHS};
    // Define the replacements for COR
    BIN(&&)->{==,LHS,RHS,FALSE};
    BIN(||)->{!=,LHS,RHS,TRUE};
    // Define the type of statement that STD should delete
    DEL(RETURN);

    // Enable the STD, COR, and ROR mutation operators
    STD;
    COR;
    ROR;
}
// Call the defined operator group for the target method
targetOp<"triangle.Triangle::classify(int,int,int)">;

解读一下，STD变异算子允许对RETURN语句进行删除。

DEL(RETURN);
// Enable the STD, COR, and ROR mutation operators
STD;

想要对tutorial.mml进行编译，生成后续变异分析要用的.mml.bin文件，只需要执行

major路径/bin/mmlc tutorial.mml tutorial.mml.bin

其中tutorial.mml.bin可以自己取名

2. 生成变异体

生成了.mml.bin文件后，就可以做变异分析了。
在major目录下执行执行

./bin/javac -XMutator=./mml/tutorial.mml.bin -d ./bin ./example/ant/src/triangle/Triangle.java

结果

#Generated Mutants: 86 (134 ms)

在major目录下生成mutants.log，可以查看变异体

1:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):11:a <= 0 |==> a < 0
2:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):11:a <= 0 |==> a == 0
3:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):11:a <= 0 |==> true
4:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):11:b <= 0 |==> b < 0
5:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):11:b <= 0 |==> b == 0
6:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):11:b <= 0 |==> true
7:COR:||(boolean,boolean):!=(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 |==> a <= 0 != b <= 0
8:COR:||(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 |==> a <= 0
9:COR:||(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 |==> b <= 0
10:COR:||(boolean,boolean):TRUE(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 |==> true
11:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):11:c <= 0 |==> c < 0
12:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):11:c <= 0 |==> c == 0
13:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):11:c <= 0 |==> true
14:COR:||(boolean,boolean):!=(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 || c <= 0 |==> (a <= 0 || b <= 0) != c <= 0
15:COR:||(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 || c <= 0 |==> a <= 0 || b <= 0
16:COR:||(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 || c <= 0 |==> c <= 0
17:COR:||(boolean,boolean):TRUE(boolean,boolean):triangle.Triangle@classify(int,int,int):11:a <= 0 || b <= 0 || c <= 0 |==> true
18:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):12:return Type.INVALID; |==> <NO-OP>
19:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):14:a == b |==> a <= b
20:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):14:a == b |==> a >= b
21:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):14:a == b |==> false
22:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):16:a == c |==> a <= c
23:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):16:a == c |==> a >= c
24:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):16:a == c |==> false
25:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):18:b == c |==> b <= c
26:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):18:b == c |==> b >= c
27:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):18:b == c |==> false
28:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):20:trian == 0 |==> trian <= 0
29:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):20:trian == 0 |==> trian >= 0
30:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):20:trian == 0 |==> false
31:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):21:a + b <= c |==> a + b < c
32:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):21:a + b <= c |==> a + b == c
33:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):21:a + b <= c |==> true
34:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):21:a + c <= b |==> a + c < b
35:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):21:a + c <= b |==> a + c == b
36:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):21:a + c <= b |==> true
37:COR:||(boolean,boolean):!=(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b |==> a + b <= c != a + c <= b
38:COR:||(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b |==> a + b <= c
39:COR:||(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b |==> a + c <= b
40:COR:||(boolean,boolean):TRUE(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b |==> true
41:ROR:<=(int,int):<(int,int):triangle.Triangle@classify(int,int,int):21:b + c <= a |==> b + c < a
42:ROR:<=(int,int):==(int,int):triangle.Triangle@classify(int,int,int):21:b + c <= a |==> b + c == a
43:ROR:<=(int,int):TRUE(int,int):triangle.Triangle@classify(int,int,int):21:b + c <= a |==> true
44:COR:||(boolean,boolean):!=(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b || b + c <= a |==> (a + b <= c || a + c <= b) != b + c <= a
45:COR:||(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b || b + c <= a |==> a + b <= c || a + c <= b
46:COR:||(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b || b + c <= a |==> b + c <= a
47:COR:||(boolean,boolean):TRUE(boolean,boolean):triangle.Triangle@classify(int,int,int):21:a + b <= c || a + c <= b || b + c <= a |==> true
48:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):22:return Type.INVALID; |==> <NO-OP>
49:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):24:return Type.SCALENE; |==> <NO-OP>
50:ROR:>(int,int):!=(int,int):triangle.Triangle@classify(int,int,int):25:trian > 3 |==> trian != 3
51:ROR:>(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):25:trian > 3 |==> trian >= 3
52:ROR:>(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):25:trian > 3 |==> false
53:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):26:return Type.EQUILATERAL; |==> <NO-OP>
54:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):27:trian == 1 |==> trian <= 1
55:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):27:trian == 1 |==> trian >= 1
56:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):27:trian == 1 |==> false
57:ROR:>(int,int):!=(int,int):triangle.Triangle@classify(int,int,int):27:a + b > c |==> a + b != c
58:ROR:>(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):27:a + b > c |==> a + b >= c
59:ROR:>(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):27:a + b > c |==> false
60:COR:&&(boolean,boolean):==(boolean,boolean):triangle.Triangle@classify(int,int,int):27:trian == 1 && a + b > c |==> trian == 1 == a + b > c
61:COR:&&(boolean,boolean):FALSE(boolean,boolean):triangle.Triangle@classify(int,int,int):27:trian == 1 && a + b > c |==> false
62:COR:&&(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):27:trian == 1 && a + b > c |==> trian == 1
63:COR:&&(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):27:trian == 1 && a + b > c |==> a + b > c
64:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):28:return Type.ISOSCELES; |==> <NO-OP>
65:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):29:trian == 2 |==> trian <= 2
66:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):29:trian == 2 |==> trian >= 2
67:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):29:trian == 2 |==> false
68:ROR:>(int,int):!=(int,int):triangle.Triangle@classify(int,int,int):29:a + c > b |==> a + c != b
69:ROR:>(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):29:a + c > b |==> a + c >= b
70:ROR:>(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):29:a + c > b |==> false
71:COR:&&(boolean,boolean):==(boolean,boolean):triangle.Triangle@classify(int,int,int):29:trian == 2 && a + c > b |==> trian == 2 == a + c > b
72:COR:&&(boolean,boolean):FALSE(boolean,boolean):triangle.Triangle@classify(int,int,int):29:trian == 2 && a + c > b |==> false
73:COR:&&(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):29:trian == 2 && a + c > b |==> trian == 2
74:COR:&&(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):29:trian == 2 && a + c > b |==> a + c > b
75:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):30:return Type.ISOSCELES; |==> <NO-OP>
76:ROR:==(int,int):<=(int,int):triangle.Triangle@classify(int,int,int):31:trian == 3 |==> trian <= 3
77:ROR:==(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):31:trian == 3 |==> trian >= 3
78:ROR:==(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):31:trian == 3 |==> false
79:ROR:>(int,int):!=(int,int):triangle.Triangle@classify(int,int,int):31:b + c > a |==> b + c != a
80:ROR:>(int,int):>=(int,int):triangle.Triangle@classify(int,int,int):31:b + c > a |==> b + c >= a
81:ROR:>(int,int):FALSE(int,int):triangle.Triangle@classify(int,int,int):31:b + c > a |==> false
82:COR:&&(boolean,boolean):==(boolean,boolean):triangle.Triangle@classify(int,int,int):31:trian == 3 && b + c > a |==> trian == 3 == b + c > a
83:COR:&&(boolean,boolean):FALSE(boolean,boolean):triangle.Triangle@classify(int,int,int):31:trian == 3 && b + c > a |==> false
84:COR:&&(boolean,boolean):LHS(boolean,boolean):triangle.Triangle@classify(int,int,int):31:trian == 3 && b + c > a |==> trian == 3
85:COR:&&(boolean,boolean):RHS(boolean,boolean):triangle.Triangle@classify(int,int,int):31:trian == 3 && b + c > a |==> b + c > a
86:STD:<RETURN>:<NO-OP>:triangle.Triangle@classify(int,int,int):32:return Type.ISOSCELES; |==> <NO-OP>

也可以使用ant来做变异，进入到example/ant目录，把mml.bin文件拷贝进来
在这里插入图片描述

然后执行即可得到和上面一样的mutants.log

ant -DmutOp="=tutorial.mml.bin" compile

解释一下如何配置ant，进入到build.xml
需要配置三个property

    <property name="mutOp" value=":NONE"/>
    <property name="mutator" value="-XMutator${mutOp}"/>
    <property name="major" value="../../bin/javac"/>

然后在compile这一个target中配置 executable=${major} 以及 <compilearg> 标签。开启export=True即可导出变异体。

    <target name="compile" depends="init" description="Compile">
        <javac includeantruntime="true" 
               srcdir="src"
              destdir="bin"
                debug="yes"
	             fork="yes"
	       executable="${major}">
	       <!-- 导出mutants文件
 			<compilerarg value="-J-Dmajor.export.mutants=true"/>
 			-->
            <compilerarg value="${mutator}"/>
        </javac>
    </target>

mutants目录下即可得到全部的mutants的.java文件
在这里插入图片描述

执行compile后执行

ant mutation.test

得到
在这里插入图片描述
会额外生成文件，保存变异分析结果
在这里插入图片描述
具体可以参考example/ant/run.sh脚本。

PLUS，如果想生成更多mutation analysis的细节，可以修改buil.xml中的junit，给一个示例。

        <junit
            printsummary="false"
            showoutput="false"
            fork="no"
            exportKillMap="true"
            resultFile="results.csv"
            mutationAnalysis="true"
            exportCovMap="true"
            timeoutFactor="16"
            sort="sort_methods"
            haltonfailure="true"
            killDetailsFile="${major.kill.log}"
            excludeFile="${major.exclude}"
            >

3. 再谈Mutator

Major支持如下变异算子
在这里插入图片描述

all.mml脚本虽然enable了所有变异算子，但是LVR默认是不起作用的，需要添加LIT()才能生成LVR类型的变异体。

LIT(BOOLEAN);
LIT(NUMBER);
LIT(STRING);

想要生成全部的mutants：

# build.xml
<property name="mutOp" value=":NONE" />
<property name="mutator" value="-XMutator${mutOp}" />
<property name="major" value="路径/bin/javac" />

<javac fork="yes" executable="${major}">
	<compilerarg value="${mutator}"/>
	<compilerarg value="-J-Dmajor.export.mutants=true"/>
</javac>

# shell

#!/bin/sh
$MAJOR_HOME/bin/ant \
-f 路径/build.xml \
-DmutOp=":ALL" \
clean compile

参考 参考链接

Carsick Car
关注
专栏目录
变异测试变异算子构思路
Criss@陈磊
03-31 1130
变异测试：是一种通过将错误注入代码并查看测试是否检测到错误来评估测试质量的方法。 常用的变异算子的构造方法： if条件修改成相反的 def checkout(cart): if cart.items: throw Error("cart empty") return checkout_internal(cart) 变异测试，修改成如下： def checkout(cart): if not cart.items: throw Error("cart empty") re
变异测试
悟已往之不谏，知来者之可追
02-24 2230
什么是变异测试？ 变异测试，英文Mutation Testing，是使用变异器 （切换数学运算符，更改返回类型，删除调用等）将代码修改为不同的变异（基于变异器创建新代码），并检查单元测试是否失败。好的单元测试应该使所有突变都失败（杀死）。 所以，变异测试的有效性可以衡量杀死了多少个突变。 变异测试是覆盖率的一个很好的补充。相比覆盖率，它能够使单元测试更加健壮。 执行变异测试 在执行变异测试前需要先执行单元测试，不然变异测试有可能找不到单元测试类。 找到对应模块下的pitest插件： 注： 如果是要执行指
【论文总结】并发程序变异测试研究综述_田甜，巩敦卫
RRukudo的博客
03-09 648
并发程序：   并发程序是指包含多个并发执行流程的程序． 这 些执行流程可以同时执行，并在执行过程中相互通信． 变异测试：   变异测试是一种面向缺陷的软件测试方法，变异测试 通过对被测程序注入特定类型的缺陷，评估测试数据的缺陷检测能力。 变异算子： 对被测程序进行微小改动时，依据的修改规则叫做变异算子。   第1节介绍了一些基本概念及本文研究与已有研究的不同 第2节阐述了与并发程序和变异测试技术相关的知识 第3节从变异实施、变异测试准则、测试数据生成等 3 方面，综述并发程序变异测试的研究进展 第4节讨论
Ubuntu 16.04 使用 Major mutation framework
weixin_34216107的博客
05-24 547
安装 OpenJDK-7 下载并安装 Major mutation framework，安装目录记为 MAJOR_PATH，即/....../major/ 在可修改 Java 环境的情况下，配置环境变量 # 编辑环境变量文件： sudo gedit /etc/profile # 在文件末尾输入以下内容 export MAJOR_HO...
C++程序设计基础实践：学生信息管理系统
最新发布
m0_73700621的博客
06-17 2272
C++程序设计基础实践：学生信息管理系统。本系统设计是用C++设计与实现一个学生信息管理系统，其主要功能模块包括：学生记录数据录入、增加；特定条件的学生查询；数据删除；数据更新；学生信息浏览。该系统采用 C++ 编程语言，使用的开发平台为Visual Studio 2022。另外，还需要采用文件操作等程序设计的基本技能和一些数据结构技术，例如排序，顺序表等。
major_s使用说明
Major_S的博客
04-11 723
major−s使用说明major-s使用说明major−s使用说明
JDK版本对应其major.minor version，看这一篇就够啦（附java历史版本下载地址）
慢热型网友的博客
12-06 5666
在网上查阅各种资料发现，报错信息中的61.0和52.0其实是jdk对应的major version信息，他们分别对应jdk17和jdk8😯,学到新知识我恍然大悟，那么问题又来了：其他版本的jdk对应的major version又是什么呢？这篇文章将解答这个疑惑。
白盒测试--变异测试
m0_62410106的博客
11-13 937
仅有4行代码的Min函数经过Mothra变异系统可以生成44个变异体 30行代码的三角形分类程序能产生951个变异体 变异测试需要运行大量的变异体，每一变异体至少需要执行一个测试用例以便将其杀死，这就需要大量的计算能力。做法：基于良好定义的变异操作，对程序进行微小的合乎语法的修改，得到源程序的变异程序。变异算子是一种产生变异体的机制。测试集T的变异分数记为MS（T）， 其中：|D|表示：杀死的变异体数 |E|表示：等价的变异体数 |M|表示：生成的所有变异体数。
pitest-example_JAVA变异测试_greatestd76_自动化测试_pitest_
10-01
代码变异，要把变异算子分类，把所有变异算子根据分类方法评估其重要性，在其可以实行的基础进行优化去变异代码。第二步就是确定变异的实现方式和对应变异算法的优化，要...确定好实现方式后，需要进行变异测试编写。
变异测试工具mujava的相关jar包
01-13
在使用Mujava进行变异测试时，你需要确保正确安装了所有依赖。首先，下载并解压提供的压缩包，里面应包含Mujava的jar文件、OpenJava和JUnit的相关文件。安装步骤通常如下： 1. 将JUnit的jar文件添加到你的项目类...
5.5 变异测试1
08-03
变异测试是一种用于评估测试套件充分性的方法，其核心思想是通过修改（变异）源代码来创建程序的多个变体（变异体），然后用现有的测试用例去运行这些变体，观察它们是否能产生不同的结果。这个过程有助于揭示测试...
defects4j使用说明
qq_41914302的博客
03-13 4746
defects4j的安装及使用说明可以参考github上readme，这里主要说一下自己在进行defects4j使用过程中的一些心得体会，帮助之后用到的同学们理解。 目录结构 首先看一下文件结构，首先是project_repos,指提供的含有故障的项目的版本控制库，之后是major,是主要的变异框架，再framework中存在我们比较需要的各种信息，重点关注projects，里面是各种真实故障的项目。 以Lang为例，讲解一下里面的目录结构 Lang 逻辑是这样的，对...
java变异测试(杀死突变体)
kirsten111111的博客
03-23 1170
此外，模型的突变体可能代表相当不同的故障类别，因此终止此类突变体的测试用例可能会发现为终止代码而生成的测试用例未发现的故障。通常，我们会产生一个突变体通过仅应用一个运算符的一个实例：此类突变体是一阶的突变体。如果每个突变体都被 T 杀死，则认为测试套件 T 是足够的：对于每个（非等价的）突变体 p’在 M 中，T 中有一些测试用例 t 杀死了 p’. 突变覆盖率是被杀死的非等价突变体的百分比。只使用一阶突变体的原因是务实的：如果我们不将我们限制在一阶突变体，那么突变体的总数是可能是巨大的。
变异测试(mutation testing)：一种评估测试用例集错误检测能力的方法
行步至春深
10-03 3819
错误检测能力如何衡量？一个朴素的想法是，对源程序做一些微小的改动，改动后的程序被称作变异程序/变异体。理想的测试脚本会让源程序通过，而拦截住所有的变异程序。
Major
Major_S的博客
12-31 422
MajorMajorMajor https://github.com/Major357/Major
Mutation Testing(变异测试)
weixin_34101229的博客
05-15 2263
　　变异测试是一种 fault-based 的软件测试技术。这项技术已经广泛研究并使用了三十余年。它为软件测试贡献了一系列方法，工具，和可靠的结果。本文将对变异测试进行深入的调查，分析它的优势和不足之处，并对比几种不同的变异测试方法，提出一些改进的建议。 　　下面用一个例子来解释什么是变异测试，考虑以下代码片段： 　　if(a && b) c = 1; 　　else c = ...
使用muJava进行变异测试
Kw学编程
07-20 9205
µJava (muJava)是针对Java程序的变异测试系统
程序变异测试与软件白盒测试策略
"程序变异测试-软件测试教程-宫云战_第3章" 在软件测试领域，程序变异测试是一种强化测试方法，旨在提高测试覆盖率和验证程序的正确性。本章详细介绍了程序变异测试的概念和技术，同时涵盖了白盒测试中的控制流测试...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值