利用状态等价加速突变分析

139 浏览量更新于2024-08-27 收藏 695KB PDF 举报

"通过等价模态更快的突变分析" 这篇研究论文探讨了如何通过等价模态来加速突变分析，以提高软件测试效率和故障定位的准确性。突变分析是一种常用的技术，用于评估测试套件的质量，通过引入人工错误（即突变体）来检查测试用例是否能有效捕获这些错误。然而，突变分析的一个主要问题是其可扩展性不足，因为需要对每个突变体执行完整的测试套件。最新的研究尝试通过分裂流执行来减少冗余的执行，这种方法可以消除在第一个突变语句之前的重复执行。但这种方法对于第一个突变语句之后的冗余执行仍然无能为力。论文作者注意到，尽管许多突变的语句本身不等价，但它们在当前状态下的执行结果可能与原始语句的结果等价，即在模态意义上等价。基于这一观察，论文提出了一个快速的突变分析方法。该方法利用等价模态的概念，识别那些在特定状态下执行结果与原始语句相同，即使它们在语法上不同。通过这种方式，可以跳过某些不需要的测试，从而减少总的执行时间，提高突变分析的效率。论文中，作者们设计并实现了一种算法，该算法能够检测和利用这种等价性，减少不必要的测试用例执行。他们可能还进行了一系列实验，以验证该方法的有效性和在实际软件项目中的性能提升。实验结果可能表明，通过等价模态的分析，可以在保持分析精度的同时，显著降低计算成本。此外，这种方法可能还有助于优化测试套件，通过识别出对突变体不敏感的测试用例，指导测试用例的改进和优化。这不仅可以节省时间和资源，还能提高测试覆盖度，从而更有效地发现和定位软件中的潜在问题。这篇研究论文为解决突变分析的可扩展性问题提供了一个新的视角，通过等价模态的概念，提出了一种能加快突变分析速度的策略。这种方法有望成为软件测试领域的一个重要工具，尤其对于大型复杂软件项目，可以显著提高测试效率，降低维护成本。

Faster Mutation Analysis via Equivalence Modulo States ISSTA’17, July 10-14, 2017, Santa Barbara, CA, USA

test as a dierent input data, we can parallelize the execution of

dierent tests on one mutant on a SIMD machine.

Finally, in the application of evaluating a test, several papers [

] propose to prioritize the tests for each mutation so that this

mutation shall be killed quicker. e works are orthogonal to ours

and can be used together with AccMut.

3 BASIC FRAMEWORK OF ACCMUT

3.1 Overview

We rst describe the redundant execution that AccMut avoids with

an example in the following code snippet and in Figure 1. In func-

tion

foo

, the line 6 is a computation intensive function without

side-eects. e test driver function is

test foo

, which sets the

parameter

and then judges the result. Let us assume that

three mutants are generated in the function

foo

. Mutant 1 (M1)

changes

a = a + 1

at line 3 into

a = a << 1

. Mutant 2 (M2) and

Mutant 3 (M3) change

a = a / 2

at line 5 into

a = a + 2

and

a = a

* 2, respectively.

In standard mutation analysis, we execute all mutants for each

test and obtain their testing results. We show the execution of the

three mutants in Figure 1(b), (c) and (d), and the execution of the

original program in Figure 1(a) as a reference.

1 i n t foo ( i n t a ) {

2 i n t i , r e s ;

3 a = a + 1 ; / / M1 : a << 1

4 f o r ( i = 0 ; i < 2 ; i ++){

5 a = a / 2 ; / / M2 : a + 2 , M3 : a ∗ 2

6 r e s += tim e cons u m i n g ( a ) ;

7 }

8 r e t u r n r e s ;

9 }

10 void t e s t f o o ( ) {

11 a s s e r t ( f o o ( 1 ) == RESULT ) ;

12 }

e circles represent system states and the states with the same

number are the same. e states are captured at the program point

listed on the le of Figure 1. e arrows represent the transition

of states aer the executions of statements. And the length of

the arrows means the execution eort during the transition. If

two transitions have the same starting state and the same ending

state, the two transitions are redundant. To show the redundancy

between states and transitions, we use the brightness of circles

and the thickness of arrows respectively. e darker a circle is, or

the thicker an arrow is, the more redundant the state/transition

is. As we can see from Figure 1(b), (c) and (d), there are several

redundant transitions among the three mutant executions. First, as

the parameter

f oo

is set to 1 in this test (State 1), the results of

a = a +

1 and

a = a <<

1 both equal to 2 (State 2). As a result, the

transitions before entering the loop, i.e., transitions to State 1 and

transitions between States 1 and 2, are redundant among the three

mutants. Second, during the rst loop

a =

2, the states of

a = a +

and

a = a ∗

2 are the same, and thus the transitions between States

2 and 5 in M2 and M3 are also redundant. Note that these two

transitions involve the call to a time-consuming function which

can induce high cost of redundancy, so the length of the arrows

during the loop is much longer.

Figure 1(e) exhibits the execution of the mutants in split-stream

execution. In split-stream execution, all mutants start as one main

process, and are later split from the main process at the rst mutated

statements. e main process of our example is shown in the rst

column in Figure 1(e). M1 is split as a new process aer State 1,

and later M2 and M3 are split as new processes aer State 2. We

need to keep the main process as more mutants may be split from it.

Some of the redundancy is removed in split-stream execution. For

example, the transition to State 1 is shared among all the mutants

as well as the main process. However, two types of redundancy

still exists. First, the transitions between State 1 and 2 are the same

between the main process and M1, and thus it is not necessary to

split M1 from the main process. Second, although it is necessary

to split M2 and M3 aer State 2, the transitions between State 2

and State 5, which involve calling the time-consuming function,

are still redundant among the two split processes.

Our approach, AccMut, tries to further reduce the redundancy

in execution by exploiting the equivalence modulo the current

state. An execution of the three mutants in AccMut is shown in

Figure 1(f). Dierent from split-stream execution, AccMut rst

classies the next statements in dierent mutants into equivalent

classes modulo the current state, and uses one process to represent

each equivalent class. As a result, rst, since the mutated statement

in M1 is equivalent to the original statement modulo State 1, we

would not split a new process for M1. Second, the two mutated

statements in M2 and M3 are equivalent modulo State 2, so we split

only one process for them. As a result, the redundant transitions in

Figure 1(e) are all removed in Figure 1(f).

More concretely, at each state of each process, we conduct a

trial execution of the statements and collect their changes to the

system state. en we cluster their changes to the system state into

equivalence classes. If the number of equivalence classes is more

than one, say

, we split

n −

1 new processes. Each forked process

represents the mutants in one equivalence class, and we apply the

change from the equivalence class to the state of the forked process.

Finally, the change from the remaining equivalent class is applied

to the original process, and the original process now represents

only the mutants in the remaining class. is process continues for

each process until all processes terminate.

However, in practice it may be expensive to store and cluster

the changes, especially when a statement makes a large set of

changes. For example, if a statement calls a procedure with a large

side eects, i.e., changing many memory locations, it may not be

ecient to record the changes of all memory locations and compare

the changes from dierent mutants.

To solve this problem, in AccMut we record abstract changes

rather than concrete changes. An abstract change stores oen much

less information than a concrete change, but nevertheless allows

the application of the change to the system state. For example, the

change of a procedure call can be represented abstractly by the

address of the procedure and all arguments passed to the procedure,

rather than all concrete changes produced by the procedure. When

we need to apply the change to system, we just actually invoke the

method with the arguments. In this way, we record only a small

amount of information allowing us to eciently store and cluster

the changes.

297

剩余11页未读，继续阅读

weixin_38627234

粉丝: 4
资源: 934

利用状态等价加速突变分析

ansys支架静力、屈曲及模态分析

实验模态分析及其应用

motaifenxi.rar_MATLAB 模态分析_模态_模态分析_模态分析 matlab_系统的模态

dk.zip_模态_模态分析_模态分析程序_模态刚度_灵敏度分析

wavelet.rar_matlab阻尼比_固有模态_小波分析_小波模态分析_模态分析

FDD.zip_FDD模态_FDD模态分析_fdd_模态分析

motaifenxi_1.zip_MATLAB 模态分析_matlab模态分析_模态_模态分析_阻尼比

模态分析_梁模态_模态分析的h1h2_matlab_简支梁_模态分析_

材料力学之动力学分析算法：模态分析：模态分析中的误差分析与控制.Tex.header.docx

rotor-modal-analysis_rotor_悬臂梁模态分析_轴承_模态分析_轴承分析.zip

最新资源