WO2022100447A1 - 单元测试代码结构自动解析与路径分析方法 - Google Patents

单元测试代码结构自动解析与路径分析方法 Download PDF

Info

Publication number
WO2022100447A1
WO2022100447A1 PCT/CN2021/127039 CN2021127039W WO2022100447A1 WO 2022100447 A1 WO2022100447 A1 WO 2022100447A1 CN 2021127039 W CN2021127039 W CN 2021127039W WO 2022100447 A1 WO2022100447 A1 WO 2022100447A1
Authority
WO
WIPO (PCT)
Prior art keywords
path
node
analysis
function
nodes
Prior art date
Application number
PCT/CN2021/127039
Other languages
English (en)
French (fr)
Inventor
黄翰
刘方青
凌霄
林锋
曹捷
庄少阳
郝志峰
Original Assignee
华南理工大学
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 华南理工大学 filed Critical 华南理工大学
Priority to US18/013,557 priority Critical patent/US20230185703A1/en
Publication of WO2022100447A1 publication Critical patent/WO2022100447A1/zh

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/43—Checking; Contextual analysis
    • G06F8/433—Dependency analysis; Data or control flow analysis
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/3668—Software testing
    • G06F11/3672—Test management
    • G06F11/3684—Test management for test design, e.g. generating new test cases
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/3668—Software testing
    • G06F11/3672—Test management
    • G06F11/3688—Test management for test execution, e.g. scheduling of test suites
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/42—Syntactic analysis
    • G06F8/427—Parsing

Definitions

  • the invention relates to the software testing field of computer software engineering, in particular to a unit testing code structure automatic analysis and path analysis method.
  • BPEL4WS is based on simple path coverage, while EvoSuite It can only analyze branch coverage and statement coverage. Among all types of coverage in software testing, path coverage is the strongest coverage, with stronger error correction capabilities, and can more effectively detect software flaws and errors.
  • the first step to achieve unit test path coverage is to analyze the program to obtain the path to be covered, program flow chart and other related information, but most of the existing technologies require manual participation, which greatly increases the testing cost .
  • the invention provides a unit testing code structure automatic analysis and path analysis method.
  • the purpose of the present invention is to design a reasonable unit test code automatic parsing and path analysis method to help software testers to quickly obtain the structure of the program that needs to be covered under the path coverage criterion, path information and path coverage analysis of test cases, thereby Use this information to generate test cases to better detect possible bugs in the test program and fix program vulnerabilities.
  • the object of the present invention is achieved by at least one of the following technical solutions.
  • the unit test code structure automatic parsing and path analysis method includes the following steps:
  • step S3 analyze the set of small segment paths obtained in step S2, and replace the part including nesting to obtain the set of small segment paths that do not include nesting;
  • step S4 based on the set of small segment paths obtained in step S3 that does not include nesting, initialize the path table between the nodes, and use the depth-first DFS algorithm to update the path table, and obtain the path set according to the path table;
  • step S5 if all path sets are covered, that is, all path sets have been updated, skip to step S6, otherwise skip to step S4;
  • step S2 the compiled bytecode is traversed, and in the traversal process, the nodes that need to be instrumented include the beginning of the function, the end of the function, the general execution statement segment, the branch statement, the loop statement, and the function or class. Nested statements.
  • the preset class insertion function Data.add(temp) is used to implement the instrumentation of the node, where temp represents the string of node information and node encoding, and Data is the path information.
  • temp represents the string of node information and node encoding
  • Data is the path information.
  • N Stored class; in the process of encoding each node of the path, a global variable N is set, and its initial value is set to 0.
  • N N + 1 update value
  • Branch loop statements include if, switch, for, and while.
  • step S2 preprocessing is performed while traversing the compiled bytecode, and the node code of the instrumentation and the constraint expression information appearing in the branch statement, loop statement, and function nesting are obtained, and the The variable information is backtracked to find the original input variable expression, which is convenient for subsequent analysis of path feasibility.
  • step S2 every time the node traversed to the instrumentation will be stored, and a small path between two nodes will be formed according to the traversal order, for example, the following program example:
  • a multi-segment path such as (A, invoke.C) (invoke.C, B) will be formed, which is convenient for subsequent replacement.
  • step S3 on the basis of the small-segment path set composed of pairs of nodes obtained in step S2, traverse the small-segment path set, find a path marked with a function call label in the path set, and obtain the corresponding function through the label.
  • the path set of the function path set is used to replace the path marked with the function call label in the original path set to form a small segment path set without function nesting or class nesting.
  • step S4 the path table M between the nodes is initialized using the set information obtained in step S3 that does not include the nested small segment path set, and the number of rows and columns of the path table M are the number of nodes; Then, using the depth-first algorithm DFS, taking the starting node of the function as the starting point of the path, the path table M is depth-first traversed according to the adjacency relationship between the nodes, and the traversed nodes are recorded during the traversal process. When the current traversal is completed, the recorded node passed by the current traversal is taken out and recorded as a complete path, and then the traversal is performed again, and all other complete paths are generated according to the same method.
  • the pseudocode of step S4 is as follows:
  • the top node of the stack is popped:
  • the path table M represents the adjacency relationship between path nodes, and each column and row represents whether there is a path between the nodes, wherein the leftmost column represents the node at the starting point of the path, and the top row represents the node at the end point of the path. For a cell, if there is a path to the node corresponding to the row of the cell to reach the node corresponding to the column of the cell, the value of the cell is set to 1, otherwise it is 0.
  • step S5 due to the existence of loop statements, the number of paths in the unit program may increase sharply, and the number of paths that need to be covered in the end cannot be determined. K times, determine the set of paths that need to be covered, for example:
  • step S6 after obtaining all path coding information through step S4 and step S5, a tree structure diagram of the node will be constructed through statistical analysis of the path node information, thereby obtaining a complete flow chart of the test unit program. ,details as follows:
  • the unit code to be tested is compiled and processed to obtain the bytecode; then the bytecode is traversed to determine the judgment, loop branch, function nesting, etc. of the tested program , Instrument the mark in the program, and obtain the symbol code at the branch node and other data references and calculation expressions, etc., while traversing the bytecode, obtain the node information of the two connected nodes between the marked nodes, and obtain the set of paths of the small segment of the tested program.
  • the complete set of small-segment paths is obtained, and then the path table is initialized with the small-segment path set, and the complete path table is obtained by using the depth-first search algorithm. Finally, the method will be used in the obtained constraint expression. On the basis, combined with the path branch information, the constraint expressions under the feasible path are analyzed, the infeasible paths are eliminated, the final obtained path set is output, and the final program flow chart CFG is obtained through the path node synthesis algorithm.
  • the present invention has the following advantages and technical effects:
  • the invention adopts the method of automatically instrumenting the marking code and analyzing the compiled bytecode, which can obtain the internal information of the nested function existing in the tested function, form a complete path, and use the obtained path constraint expression to eliminate those redundant
  • the non-coverable path reduces the pressure of subsequent generation of path coverage test cases, and the method can also determine the path covered by test cases in real time and provide testers with visual flow chart information.
  • Applying the related method of the present invention is relatively convenient, does not require the tester to have a deep understanding of the logic and other laws of the program to be tested, and has strong ease of use. application space.
  • the technical means adopted in the present invention can realize the automatic analysis and path analysis of the actual engineering code unit program without manual participation. On the one hand, it can automatically instrument the program, analyze the program structure, and obtain the path information that needs to be covered. It can automatically analyze the paths covered by test cases and provide important information such as evaluation functions for the path coverage algorithm, which significantly improves the efficiency of path coverage test case generation.
  • FIG. 1 is a flowchart of a method for automatic parsing and path analysis of a unit test code structure in an embodiment of the present invention.
  • FIG. 2 is a schematic diagram of a visualization result of a path set and a flowchart in an embodiment of the present invention.
  • Computer computer new Computer(a, b);
  • the dependent class is Computer, and the code is as follows:
  • the unit test code structure automatic analysis and path analysis method includes the following steps:
  • the nodes that need to be instrumented include the beginning of the function, the end of the function, the general execution statement segment, the branch statement, the loop statement, and the nested statement of the function or class;
  • the preset class insertion function Data.add(temp) is used to implement the instrumentation of the node, where temp represents the string of node information and node encoding, and Data is the class of path information storage ;
  • Branch loop statements include if, switch, for, and while.
  • Preprocessing is performed while traversing the compiled bytecode, and the node code of the instrumentation and the constraint expression information appearing in the branch statement, loop statement, and function nesting are obtained, and the variable information in it is backtracked to find out The original input variable expression is convenient for subsequent analysis of path feasibility.
  • a node Whenever a node is traversed to the instrumentation, it will be stored, and a small segment path between two nodes will be formed according to the traversal order, including function nesting and class nested nodes. Use the function call label invoke tag to replace the small segment path, which is convenient for subsequent replacement.
  • the asm library is used to traverse the compiled code to be tested, so as to implement the instrumentation of the code and the acquisition of the small path set.
  • the code after instrumentation is as follows:
  • com/moi/test/sample/Single.init:START is the node information expression
  • com/moi/test/sample is the package name of the class
  • Single corresponds to the class name
  • init corresponds to the function name where the node is located
  • after ":" is the label of the node
  • START represents the starting position of the function
  • END represents the end position of the function
  • !L1502635287 represents the value of the corresponding LABEL in the bytecode
  • the specific value is determined by the bytecode.
  • Computer var3 new Computer(var0, var1);
  • step S3 analyze the set of small segment paths obtained in step S2, and replace the part including nesting to obtain the set of small segment paths that do not include nesting;
  • step S2 On the basis of the small-segment path set composed of two nodes obtained in step S2, traverse the small-segment path set, find the path marked with the function call label in the path set, obtain the path set of the corresponding function through the label, and use the function
  • the paths in the path set replace the paths marked with function call labels in the original path set, forming a set of small-segment paths without function nesting or class nesting.
  • the set of small path segments composed of two or two nodes in the function to be tested will be obtained according to the source code logic as follows: ( The test function in the Single class is used as the function to be tested. )
  • path 1 The left half of path 1 represents the node of the function to be tested, Single.test, and the Computer.sub with the label #INVOKE# in the right half is the external function called in Single.test, so first get the function of the called function.
  • the path set of the called function is integrated into the path set of the function to be tested, so as to obtain a path set without function nesting.
  • step S4 based on the set of small segment paths obtained in step S3 that does not include nesting, initialize the path table between nodes, and use the depth-first DFS algorithm to update the path table, and obtain the path set according to the path table;
  • the path table M between nodes is initialized using the set information obtained in step S3 that does not include the nested small segment path set, and the number of rows and columns of the path table M are the number of nodes;
  • the path table M represents the adjacency relationship between path nodes, each column and row represents whether there is a path between the nodes, wherein the leftmost column represents the node at the starting point of the path, and the top row represents the node at the end point of the path.
  • the value of the cell is set to 1, otherwise it is 0.
  • the path table M is depth-first traversed according to the adjacency relationship between the nodes, and the traversed nodes are recorded during the traversal process.
  • the recorded node passed by the current traversal is taken out and recorded as a complete path, and then the traversal is performed again, and all other complete paths are generated according to the same method.
  • a path table can be obtained by removing the nested path set, and a node information mapping table is made first for this, as shown in Table 1.
  • a corresponding path table can be made, as shown in Table 2, if there is a path Lx->Ly, set the value of [Lx, Ly] to 1.
  • step S5 if all path sets are covered, that is, all path sets have been updated, skip to step S6, otherwise skip to step S4;
  • the K-loop loop path judgment method is adopted, that is, the maximum number of loops of all loops is K times by default, and it is determined that the number of paths to be covered needs to be covered.
  • a collection of paths for example:
  • the constraint expressions of the above-mentioned paths are analyzed, and the paths for which the constraint expressions cannot be solved are eliminated.
  • the loop path judgment method of K-loop is used to alleviate the situation that loop statements generate a large number of paths. As follows:
  • path 28 does not conform to the code logic and should be eliminated.
  • step S4 After obtaining all the path coding information through step S4 and step S5, the tree structure diagram of the node will be constructed through the statistical analysis of the path node information, so as to obtain the complete flow chart of the test unit program, as follows:
  • the present invention can find out the path set of the program under test, generate a corresponding flow chart, and visualize the results.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Software Systems (AREA)
  • Debugging And Monitoring (AREA)

Abstract

单元测试代码结构自动解析与路径分析方法。所述方法包括：根据测试程序的语言，获取编译后的字节码；遍历编译后的字节码，在重要语句前分别做插桩代码，同时获取结点信息与小段路径集合；分析小段路径集合，对其中包括嵌套的部分进行替换，得到不包括嵌套的小段路径集合并作为基础，初始化结点之间的路径表格，并利用深度优先DFS算法更新路径表格，依据路径表格得到路径集合；若并非所有路径集合都被覆盖即所有路径集合都已更新，则返回继续更新路径表格；输出获取的路经集合与分析得到的程序流程图CFG。上述方法使用自动嵌入插桩代码、编译并分析的方式，能够高效获取路径集合，提高了处理实际软件单元测试路径分析的能力。

Description

单元测试代码结构自动解析与路径分析方法 技术领域
本发明涉及计算机软件工程的软件测试领域，具体涉及单元测试代码结构自动解析与路径分析方法。
 背景技术
随着社会的发展与人工智能等IT领域不断应用，软件产品在生活中越来越普及，方便着生活的方方面面。软件产品的质量成为人们日益关注的焦点，生产一款质量有保证的软件产品，是生产者们的重要目标之一，也是IT企业应对市场竞争的重要砝码。软件测试作为软件开发生命中的重要过程，其目的是确保软件产品的质量。然而，软件测试花费了软件开发中至少50%的成本。软件测试有人工参与和自动化两种方式，全自动化测试在软件开发过程中还未真正普及，测试大多数情况仍然是以人工参与为主。然而技术的发展程度决定了软件的复杂程度，测试的难度和工作量随之增大而人的精力却是有限的，这种局面亟待改变；另外在软件测试中存在着大量技术含量低且经常重复的工作，若使用机器来完成将可以大大地减少人力的消耗；因此，以自动化的方式对软件进行测试是解决当前问题的最佳方案。一个优秀的自动化测试方案，可以节约大量的人力、物力和财力，减少资源消耗，同时提高企业效益。
为了尽可能减少软件的缺陷，需要生成无穷多个测试用例来对它进行测量。无论一个程序的规模有多大，对其输入进行穷举在现实世界中都是不可行的，所以在测试过程中需要找到一种优化方法，在不对质量妥协的情况下，减少资源（如时间、成本、人力资源、系统部件等等）的消耗。优化的目标是用尽可能少的时间和成本生成一些能够覆盖被测试系统中有效的测试用例。
现有的方法中使用的动态的方法大都是具体基于语句覆盖或者是分支覆盖，例如面向并行程序的路径分析工具BPEL4WS（Yan J, Li Z, Yuan Y, et al. BPEL4WS unit testing: Test case generation using a concurrent path analysis approach[C]//2006 17th International Symposium on Software Reliability Engineering. IEEE, 2006: 75-84.）与软件单元测试工具EvoSuite（Fraser G, Arcuri A. Evosuite: automatic test suite generation for object-oriented software[C]//Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering. 2011: 416-419.），这些工具虽然有路径分析与生成测试用例的功能，但其覆盖准则都没有实现较完备的路径覆盖，BPEL4WS基于简单路径覆盖，而EvoSuite也只能分析分支覆盖、语句覆盖。而在软件测试所有的覆盖类型中，路径覆盖是最强的覆盖，有更强的纠错能力，能更有效地检查出软件的瑕疵和错误。而实现单元测试路径覆盖的第一步是对程序进行分析，从而获取需要覆盖的路径、程序流程图以及其他相关信息，但是现有的技术大部分是需要人工参与，这极大提高了测试代价。
 技术解决方案
本发明针对现有的软件测试测试用例生成软件系统的不足，提供了单元测试代码结构自动解析与路径分析方法。本发明的目的在于设计一种合理的单元测试代码自动解析与路径分析方法，帮助软件测试人员能够快速的获得路径覆盖准则下需要覆盖程序的结构、路径信息以及测试用例的路径覆盖情况分析，从而利用这些信息生成测试用例，进而更好地检测出测试程序可能存在的BUG，用于修复程序漏洞。
本发明的目的至少通过如下技术方案之一实现。
单元测试代码结构自动解析与路径分析方法，包括以下步骤：
S1、根据测试程序的语言，使用对应语言的编译器获取编译后的字节码；
S2、遍历编译后的字节码，在重要语句前分别做插桩代码，同时获取结点信息与小段路径集合；
S3、分析步骤S2中获取的小段路径集合，对其中包括嵌套的部分进行替换，得到不包括嵌套的小段路径集合；
S4、以步骤S3中得到的不包括嵌套的小段路径集合为基础，初始化结点之间的路径表格，并利用深度优先DFS算法更新路径表格，并依据路径表格得到路径集合；
S5、若所有路径集合都被覆盖即所有路径集合都已更新，跳至步骤S6，否则跳至步骤S4；
S6、输出获取的路经集合与分析得到的程序流程图CFG。
进一步地，步骤S2中，对编译后的字节码进行遍历，在遍历过程中，需要插桩的结点包括函数开头、函数结尾、一般执行语句段、分支语句、循环语句以及函数或类的嵌套语句。
进一步地，当搜索到对应结点时，使用预设的类插入函数Data.add(temp)实现该结点的插桩，其中temp代表结点信息与结点编码的字符串，Data为路径信息存储的类；在对路径每个结点编码过程中，设置一个全局变量 N，其初始值设为0，每次遍历到特定结点时就将其编码赋值为 N，之后通过 N=N+1更新值；
在遍历到函数开头、函数结尾以及分支循环语句时使用插桩语句对字节码进行插桩，将相对应的节点信息插入到相应位置；
分支循环语句包括if、switch、for和while。
进一步地，步骤S2中，在遍历编译后的字节码的同时进行预处理，获取插桩的结点编码以及分支语句、循环语句、函数嵌套中出现的约束表达式信息，同时对其中的变量信息进行回溯，找出原始的输入变量表达式，方便后续分析路径可行性。
进一步地，步骤S2中，每当遍历到插桩的结点将进行存储，并按照遍历顺序组成两两结点之间的小段路径，例如以下程序示例：
 do A；
 if(true) do B；
 else do C；
do D；
将分别形成(A,B) (A,C) (B,D) (C,D)等多段小段路径，其中包括函数嵌套、类的嵌套的结点使用函数调用标签invoke标记代替该小段路径，如下列示例代码：
do A;
 method C();//此处调用函数C
do B;
将形成(A，invoke.C)(invoke.C，B)等多段小段路径，方便后续进行替换。
进一步地，步骤S3中，在步骤S2中获取的两两结点组成的小段路径集合的基础上，遍历小段路径集，找到路径集中带有函数调用标签标记的路径，通过该标签获取对应的函数的路径集合，使用该函数路径集中的路径替换原路径集中的带有函数调用标签标记的路径，形成没有函数嵌套或类的嵌套的小段路径集合。步骤S3的伪代码如下所示：
for(路径_1 in A路径集)  
{  
    if(路径_1->终点 == invoke){  
        获取路径_1->终点所调用的函数B的路径集;  
        for(路径_2 in B路径集)  
        {  
            if(路径_2->起点 == start){  
                将路径_1->终点替换为路径_2->起点;  
                导入B路径集中其他路径;  
            }  
         }  
     }  
     if(路径_1->起点 == invoke){  
        获取路径_1->起点所调用的函数B的路径集;  
        for(路径_2 in B路径集)  
        {  
            if(路径_2->终点 == end){  
                将路径_1->起点替换为路径_2->终点;  
                导入B路径集中其他路径;  
            }  
         }  
     }  
}  。 
进一步地，步骤S4中，利用步骤S3中获取的不包括嵌套的小段路径集合的集合信息初始化结点之间的路径表格 M，路径表格 M的行数与列数均为结点个数；之后利用深度优先算法DFS，以函数的起始节点为路径起点，对路径表格M根据节点之间的邻接关系进行深度优先遍历，遍历过程中记录所遍历到的节点，当遍历到该函数的终止节点时，当前遍历结束，取出记录到的当前遍历所经过的节点并记为一条完整路径，之后重新进行遍历，按照相同方法生成其他所有完整路径。步骤S4的伪代码如下所示：
for 节点 in 函数节点集  
{  
    if 节点为start  
    {  
         将节点压栈;  
    }  
}  
  
while 节点栈非空  
{  
    if 栈顶节点为end  
    {  
         将目前栈中的节点保存并形成完整路径:  
         栈顶节点出栈:  
    }  
    else  
    {  
         遍历路径表格，获取路径表格上栈顶节点所在的一行中从左往右第一个数据为1且未被访问的节点:  
         若该节点存在，则将此节点压栈，同时设定为已访问:  
    }  
} 
进一步地，所述路径表格 M表示的是路径节点之间的邻接关系，每列每行代表节点之间是否存在路径，其中最左列代表路径起点的节点，最上行代表路径终点的节点，对于一个单元格来说，若该单元格所在行所对应的节点存在一条路径能到达该单元格所在列所对应的节点，则该单元格的值置为1，否则为0。
进一步地，步骤S5中，由于存在循环语句，可能导致单元程序的路径数量暴增，无法确定最终需要覆盖的路径数量，采用K-loop的循环路径判断方法，即默认所有循环的最大循环次数为K次，判定需要覆盖的路径集合，例如：
While (a<10)
{ print(“a”); }
假设K=2，1表示进入循环，0表示未进入循序，那么该路径片段就存在00,01,10,11四种可能；同时利用符号执行技术，分析路径的约束表达式，从而判定路径的可行性，去除不可行路径，例如类似(a==0&&a==1)这种会导致约束表达式无解的路径，优化得到最终需要覆盖的单元程序路径集合。
进一步地，步骤S6中，在通过步骤S4和步骤S5获取所有路径编码信息后，将通过对路径结点信息的统计分析，构建结点的树形结构图，从而得到测试单元程序的完整流程图，具体如下：
首先，将找出每个结点前出现次数最多的前置结点，在流程图（树）中将此结点的前置结点作为此结点的父节点；按照此规律，由起始节点开始，遍历所有未放置过的结点，构建树形结构，从而获取流程图信息。
本发明提供的单元测试代码结构自动解析与分析方法，首先将被测试单元代码进行编译处理，获取字节码；接着遍历字节码，确定被测试程序的判断、循环分支、函数嵌套等内容，在程序中插桩标记，同时获取分支节点处符号编码以及其他数据引用与计算表达式等信息，遍历字节码的同时获取标记节点之间两两相连节点信息，得到被测试程序小段路径集合；然后通过替换潜在的嵌套节点等路径信息，获取完整的小段路径集合，接着使用小段路径集合初始化路径表格，并利用深度优先搜索算法得到完整的路径表格，最后方法将在获取的约束表达式基础上，结合路径分支信息，分析路径可行下约束表达式，剔除不可行路径，并输出最终获得的路径集合并通过路径结点合成算法获取最终的程序流程图CFG。
 有益效果
与现有的技术相比，本发明具有以下优点和技术效果：
对于软件单元测试与路径分析相关的软件，市面上大多数是使用简单的随机规则，或者使用静态的符号执行的方式，前者过于简单，后者对于复杂的测试问题解决能力不强，而本发明采取的是使用自动嵌入插桩代码、编译并分析的方式，能够高效获取路径集合，极大地提高了方法处理实际软件单元测试路径分析的能力。其次，而路径覆盖作为一种更强的覆盖准则，相应的基于路径覆盖准则找到的测试用例则拥有更强的纠错能力，而现有的程序路径分析工具，一方面没有考虑路径的可行性，另一方面缺乏对程序分支信息的获取，无法为后续路径覆盖测试用例生成提供充足的信息。本发明采用自动插桩标记代码并分析编译后字节码的方式，能够获取被测试函数中存在的嵌套函数内部信息，形成完整的路径，并利用获取的路径约束表达式，剔除那些冗余的不可被覆盖的路径，减少了后续生成路径覆盖测试用例的压力，同时方法还能够实时确定测试用例覆盖的路径并为测试人员提供了可视化的流程图信息。申请本发明的相关方法相对便捷，不需要测试人员对被测试程序的逻辑等规律有很深的了解，拥有很强的易用性，只要测试人员按照本发明的方法进行简单的操作，有广阔的应用空间。
本发明中采用的技术手段能够实现无人工参与的实际工程代码单元程序自动解析与路径分析工作，一方面能够自动对程序进行插桩，分析程序结构，获取需要覆盖的路径信息，另一方面还能够自动分析测试用例覆盖的路径并为路径覆盖算法提供评估函数等重要信息，显著提升路径覆盖测试用例生成的效率。
 附图说明
图1为本发明实施例中单元测试代码结构自动解析与路径分析方法流程图。
图2为本发明实施例中路径集合与流程图可视化结果示意图。
 本发明的实施方式
以下结合附图和实施例对本发明的实施方式作进一步说明，但本发明的实施不限于此。
实施例：
本实施例中，以一段Java示例代码为例（其中样例代码Single类的 test为待测试函数）：package com.moi.test.sample;  
  
public class Single {  
    public static void test(int a, int b) {  
        boolean n = true;  
        Computer computer = new Computer(a, b);  
        if(n == true){  
            System.out.println(4);  
        }  
        if(n != true){  
            System.out.println(4);  
        }  
        for(int i =0;i<6;i++){  
            computer.div();  
        }  
        a=a+b;  
        computer.sub();  
    }  
}  
依赖的类为Computer，代码如下：
package com.moi.test.sample;  
  
public class Computer {  
    private int a;  
    private int b;  
  
    public Computer(int a, int b) {  
        this.a = a;  
        this.b = b;  
    }  
  
    public int add() {  
        return a + b;  
    }  
  
    public int sub() {  
        return a - b;  
    }  
  
    public int div() {  
        if (b != 0) {  
            return a / b;  
        } else {  
            return -1;  
        }  
    }  
  
    public int getA() {  
        return a;  
    }  
  
    public void setA(int a) {  
        this.a = a;  
    }  
  
    public int getB() {  
        return b;  
    }  
  
    public void setB(int b) {  
        this.b = b;  
    }  
} 
单元测试代码结构自动解析与路径分析方法，如图1所示，包括以下步骤：
S1、根据测试程序的语言，使用对应语言的编译器获取编译后的字节码；
S2、遍历编译后的字节码，在重要语句前分别做插桩代码，同时获取结点信息与小段路径集合；
对编译后的字节码进行遍历，在遍历过程中，需要插桩的结点包括函数开头、函数结尾、一般执行语句段、分支语句、循环语句以及函数或类的嵌套语句；
当搜索到对应结点时，使用预设的类插入函数Data.add(temp)实现该结点的插桩，其中temp代表结点信息与结点编码的字符串，Data为路径信息存储的类；在对路径每个结点编码过程中，设置一个全局变量 N，其初始值设为0，每次遍历到特定结点时就将其编码赋值为 N，之后通过 N=N+1更新值；
在遍历到函数开头、函数结尾以及分支循环语句时使用插桩语句对字节码进行插桩，将相对应的节点信息插入到相应位置；
分支循环语句包括if、switch、for和while。
在遍历编译后的字节码的同时进行预处理，获取插桩的结点编码以及分支语句、循环语句、函数嵌套中出现的约束表达式信息，同时对其中的变量信息进行回溯，找出原始的输入变量表达式，方便后续分析路径可行性。
每当遍历到插桩的结点将进行存储，并按照遍历顺序组成两两结点之间的小段路径，其中包括函数嵌套、类的嵌套的结点使用函数调用标签invoke标记代替该小段路径，方便后续进行替换。
本实施例中，利用asm库对编译后的待测试代码进行遍历，实现对代码的插桩与小段路径集的获取，插桩后代码如下：
其中com/moi/test/sample/Single.init:START为节点信息表达式，com/moi/test/sample为类的包名，Single对应类名，init对应该节点所在函数名，“:”后为节点的标签，START代表函数的起始位置，END代表函数的结束位置，!L1502635287表示字节码中对应的LABEL的值，具体值由字节码决定。
package com.moi.test.sample;  
  
import com.moi.japaco.Data;  
import com.moi.japaco.Judge;  
  
public class Single {  
    public Single() {  
        Data.array.add("com/moi/test/sample/Single.init:START");  
        super();  
        Data.array.add("com/moi/test/sample/Single.init:END");  
    }  
  
    public static void test(int var0, int var1) {  
        Data.array.add("com/moi/test/sample/Single.test:START");  
        byte var2 = 1;  
        Computer var3 = new Computer(var0, var1);  
        Judge.if_setValue(var2, 1, "com/moi/test/sample/Single.test:I0");  
        if (var2 == 1) {  
            Data.array.add("com/moi/test/sample/Single.test:!L394721749");  
            System.out.println(4);  
        }  
  
        Data.array.add("com/moi/test/sample/Single.test:L394721749");  
        Judge.if_setValue(var2, 1, "com/moi/test/sample/Single.test:I1");  
        if (var2 != 1) {  
            Data.array.add("com/moi/test/sample/Single.test:!L1884122755");  
            System.out.println(4);  
        }  
  
        Data.array.add("com/moi/test/sample/Single.test:L1884122755");  
        int var4 = 0;  
  
        while(true) {  
            Data.array.add("com/moi/test/sample/Single.test:L1134612201");  
            Judge.if_setValue(var4, 6, "com/moi/test/sample/Single.test:I2");  
            if (var4 >= 6) {  
                Data.array.add("com/moi/test/sample/Single.test:L246550802");  
                int var10000 = var0 + var1;  
                var3.sub();  
                Data.array.add("com/moi/test/sample/Single.test:END");  
                return;  
            }  
  
            Data.array.add("com/moi/test/sample/Single.test:!L246550802");  
            var3.div();  
            ++var4;  
        }  
    }  
} 
S3、分析步骤S2中获取的小段路径集合，对其中包括嵌套的部分进行替换，得到不包括嵌套的小段路径集合；
在步骤S2中获取的两两结点组成的小段路径集合的基础上，遍历小段路径集，找到路径集中带有函数调用标签标记的路径，通过该标签获取对应的函数的路径集合，使用该函数路径集中的路径替换原路径集中的带有函数调用标签标记的路径，形成没有函数嵌套或类的嵌套的小段路径集合。
本实施例中，可以获取(var2==1)为该分支进入第一个if分支的条件，而进入else分支的条件则是(var2!=1)。
本实施例中，在使用asm库对待测试代码进行遍历插桩时，会依据源码逻辑获取待测试函数中由两两节点组成的小段路径集如下： （以 Single 类中的 test 函数作为待测试函数）
Single.test:START:L747-> Computer.init:#INVOKE#:I748  
Computer.init:#INVOKE#:I748-> Single.test:L292917034:L749  
Computer.init:#INVOKE#:I748-> Single.test:!L292917034:L750  
Single.test:!L292917034:L750-> Single.test:L292917034:L749  
Single.test:L292917034:L749-> Single.test:L242355057:L751  
Single.test:L242355057:L751-> Single.test:L455538610:L752  
Single.test:L242355057:L751-> Single.test:!L455538610:L753  
Single.test:!L455538610:L753-> Computer.div:#INVOKE#:I754  
Computer.div:#INVOKE#:I754-> Single.test:L242355057:L751  
Single.test:L455538610:L752-> Computer.sub:#INVOKE#:I755  
Computer.sub:#INVOKE#:I755->Single.test:END:L758  
从上文中的路径集中可见部分路径带有#INVOKE#标签，如：
Single.test:L455538610:L752-> Computer.sub:#INVOKE#:I755  
Computer.sub:#INVOKE#:I755->Single.test:END:L758  
其中路径1的左半部分代表待测试函数Single.test的节点，而右半部分带有#INVOKE#标签的Computer.sub则是Single.test中所调用的外部函数，因此首先获取被调用函数的小段路径集：
Computer.sub:START:L849-> Computer.sub:END:L850                                 
获取到被调用函数的小段路径集后，将原函数路径集中位于右端的INVOKE标签替换为被调用函数的起始标签START，将原函数路径集中位于左端的INVOKE标签替换为被调用函数的结束标签END：
Single.test:L455538610:L752-> Computer.sub:START:L849 
Computer.sub:END:L850->Single.test:END:L758  
并将被调用函数的路径集整合入待测试函数的路径集中，从而获得无函数嵌套的路径集。
S4、以步骤S3中得到的不包括嵌套的小段路径集合为基础，初始化结点之间的路径表格，并利用深度优先DFS算法更新路径表格，并依据路径表格得到路径集合；
利用步骤S3中获取的不包括嵌套的小段路径集合的集合信息初始化结点之间的路径表格 M，路径表格 M的行数与列数均为结点个数；
所述路径表格 M表示的是路径节点之间的邻接关系，每列每行代表节点之间是否存在路径，其中最左列代表路径起点的节点，最上行代表路径终点的节点，对于一个单元格来说，若该单元格所在行所对应的节点存在一条路径能到达该单元格所在列所对应的节点，则该单元格的值置为1，否则为0。
之后利用深度优先算法DFS，以函数的起始节点为路径起点，对路径表格M根据节点之间的邻接关系进行深度优先遍历，遍历过程中记录所遍历到的节点，当遍历到该函数的终止节点时，当前遍历结束，取出记录到的当前遍历所经过的节点并记为一条完整路径，之后重新进行遍历，按照相同方法生成其他所有完整路径。
本实施例中，通过去除嵌套的路径集可以得到一个路径表格，对此先做结点信息映射表，如表1所示。
表1结点信息映射表
Single.test:START:L747 L0
Computer.init:START:L701 L1
Computer.init:END:L702 L2
Single.test:!L292917034:L750 L3
Single.test:L292917034:L749 L4
Single.test:L242355057:L751 L5
Single.test:!L455538610:L753 L6
Single.test:L455538610:L752 L7
Computer.div:START:L707 L8
Computer.div:END:L710 L9
Computer.sub:START:L705 L10
Computer.sub:END:L706 L11
Single.test:END:L758 L12
通过结点信息映射表，可做出对应的路径表格，如表2所示，若存在路径Lx->Ly，则令【Lx，Ly】的值为1。
 
表2路径表格
  L0 L1 L2 L3 L4 L5 L6 L7 L8 L9 L10 L11 L12
L0   1                      
L1     1                    
L2       1 1                
L3         1                
L4           1              
L5             1 1          
L6                 1        
L7                     1    
L8                   1      
L9           1              
L10                       1  
L11                         1
L12                          
经过算法计算后，可得路径如下：
Single.test:START:L819->Computer.init:START:L773->Computer.init:END:L774->Single.test:L394721749:L821->Single.test:L1884122755:L823->Single.test:L1134612201:L825->Single.test:L246550802:L826->Computer.sub:START:L777->Computer.sub:END:L778->Single.test:END:L830->  
Single.test:START:L819->Computer.init:START:L773->Computer.init:END:L774->Single.test:L394721749:L821->Single.test:!L1884122755:L824->Single.test:L1884122755:L823->Single.test:L1134612201:L825->Single.test:L246550802:L826->Computer.sub:START:L777->Computer.sub:END:L778->Single.test:END:L830->  
… (共可得28条路径，内容省略)
S5、若所有路径集合都被覆盖即所有路径集合都已更新，跳至步骤S6，否则跳至步骤S4；
由于存在循环语句，可能导致单元程序的路径数量暴增，无法确定最终需要覆盖的路径数量，采用K-loop的循环路径判断方法，即默认所有循环的最大循环次数为K次，判定需要覆盖的路径集合，例如：
While (a<10)
{ print(“a”); }
假设K=2，1表示进入循环，0表示未进入循序，那么该路径片段就存在00,01,10,11四种可能；同时利用符号执行技术，分析路径的约束表达式，从而判定路径的可行性，去除不可行路径，例如类似(a==0&&a==1)这种会导致约束表达式无解的路径，优化得到最终需要覆盖的单元程序路径集合。
本实施例中，分析上述各个路径的约束表达式，对于约束表达式不可求解的路径予以剔除，同时使用K-loop的循环路径判断方法，缓解循环语句产生大量路径的情况。如下所示：
         if (var2 == 1) {  
            Data.array.add("com/moi/test/sample/Single.test:!L394721749");  
            System.out.println(4);  
        }  
  
        Data.array.add("com/moi/test/sample/Single.test:L394721749");  
        Judge.if_setValue(var2, 1, "com/moi/test/sample/Single.test:I1");  
                 if (var2 != 1) {  
            Data.array.add("com/moi/test/sample/Single.test:!L1884122755");  
            System.out.println(4);  
        }  
  
其中Single.test:!L394721749 与Single.test:!L1884122755不可能出现在同一路径中，但在上述路径列表中却有路径同时涵盖了这两个点，如路径28中的如下片段：
Single.test:!L394721749:L822->Single.test:L394721749:L821->Single.test:!L1884122755:L824->Single.test:L1884122755:L823  
因此路径28不符合代码逻辑，应剔除。
S6、输出获取的路经集合与分析得到的程序流程图CFG；
在通过步骤S4和步骤S5获取所有路径编码信息后，将通过对路径结点信息的统计分析，构建结点的树形结构图，从而得到测试单元程序的完整流程图，具体如下：
首先，将找出每个结点前出现次数最多的前置结点，在流程图（树）中将此结点的前置结点作为此结点的父节点；按照此规律，由起始节点开始，遍历所有未放置过的结点，构建树形结构，从而获取流程图信息，如图2所示。
从实施例的结果上看，本发明可以找出被测试程序的路径集合，并生成对应的流程图，将结果可视化处理。

Claims (10)

  1. 单元测试代码结构自动解析与路径分析方法，其特征在于，包括以下步骤：
    S1、根据测试程序的语言，使用对应语言的编译器获取编译后的字节码；
    S2、遍历编译后的字节码，在重要语句前分别做插桩代码，同时获取结点信息与小段路径集合；
    S3、分析步骤S2中获取的小段路径集合，对其中包括嵌套的部分进行替换，得到不包括嵌套的小段路径集合；
    S4、以步骤S3中得到的不包括嵌套的小段路径集合为基础，初始化结点之间的路径表格，并利用深度优先DFS算法更新路径表格，并依据路径表格得到路径集合；
    S5、若所有路径集合都被覆盖即所有路径集合都已更新，跳至步骤S6，否则跳至步骤S4；
    S6、输出获取的路经集合与分析得到的程序流程图CFG。
  2. 根据权利要求1所述的单元测试代码结构自动解析与路径分析方法，其特征在于，步骤S2中，对编译后的字节码进行遍历，在遍历过程中，需要插桩的结点包括函数开头、函数结尾、一般执行语句段、分支语句、循环语句以及函数或类的嵌套语句。
  3. 根据权利要求2所述的单元测试代码结构自动解析与路径分析方法，其特征在于，当搜索到对应结点时，使用预设的类插入函数Data.add(temp)实现该结点的插桩，其中temp代表结点信息与结点编码的字符串，Data为路径信息存储的类；在对路径每个结点编码过程中，设置一个全局变量 N，其初始值设为0，每次遍历到特定结点时就将其编码赋值为 N，之后通过 N=N+1更新值；
    在遍历到函数开头、函数结尾以及分支循环语句时使用插桩语句对字节码进行插桩，将相对应的节点信息插入到相应位置；
    分支循环语句包括if、switch、for和while。
  4. 根据权利要求3所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S2中，在遍历编译后的字节码的同时进行预处理，获取插桩的结点编码以及分支语句、循环语句、函数嵌套中出现的约束表达式信息，同时对其中的变量信息进行回溯，找出原始的输入变量表达式，方便后续分析路径可行性。
  5. 根据权利要求4所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S2中，每当遍历到插桩的结点将进行存储，并按照遍历顺序组成两两结点之间的小段路径，其中包括函数嵌套、类的嵌套的结点使用函数调用标签标记代替该小段路径，方便后续进行替换。
  6. 根据权利要求5所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S3中，在步骤S2中获取的两两结点组成的小段路径集合的基础上，遍历小段路径集，找到路径集中带有函数调用标签标记的路径，通过该标签获取对应的函数的路径集合，使用该函数路径集中的路径替换原路径集中的带有函数调用标签标记的路径，形成没有函数嵌套或类的嵌套的小段路径集合。
  7. 根据权利要求6所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S4中，利用步骤S3中获取的不包括嵌套的小段路径集合的集合信息初始化结点之间的路径表格 M，路径表格 M的行数与列数均为结点个数；之后利用深度优先算法DFS，以函数的起始节点为路径起点，对路径表格M根据节点之间的邻接关系进行深度优先遍历，遍历过程中记录所遍历到的节点，当遍历到该函数的终止节点时，当前遍历结束，取出记录到的当前遍历所经过的节点并记为一条完整路径，之后重新进行遍历，按照相同方法生成其他所有完整路径。
  8. 根据权利要求7所述的单元测试代码结构自动解析与路径分析方法，其特征在于：所述路径表格 M表示的是路径节点之间的邻接关系，每列每行代表节点之间是否存在路径，其中最左列代表路径起点的节点，最上行代表路径终点的节点，对于一个单元格来说，若该单元格所在行所对应的节点存在一条路径能到达该单元格所在列所对应的节点，则该单元格的值置为1，否则为0。
  9. 根据权利要求7所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S5中，采用K-loop的循环路径判断方法，即默认所有循环的最大循环次数为K次，判定需要覆盖的路径集合；同时利用符号执行技术，分析路径的约束表达式，从而判定路径的可行性，去除不可行路径，优化得到最终需要覆盖的单元程序路径集合。
  10. 根据权利要求1~9任一项所述的单元测试代码结构自动解析与路径分析方法，其特征在于：步骤S6中，在通过步骤S4和步骤S5获取所有路径编码信息后，将通过对路径结点信息的统计分析，构建结点的树形结构图，从而得到测试单元程序的完整流程图，具体如下：
    首先，将找出每个结点前出现次数最多的前置结点，在流程图中将此结点的前置结点作为此结点的父节点；按照此规律，由起始节点开始，遍历所有未放置过的结点，构建树形结构，从而获取流程图信息。
     
PCT/CN2021/127039 2020-11-13 2021-10-28 单元测试代码结构自动解析与路径分析方法 WO2022100447A1 (zh)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US18/013,557 US20230185703A1 (en) 2020-11-13 2021-10-28 Automatic parsing and path analysis method for unit test code structure

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
CN202011267313.5A CN112380120B (zh) 2020-11-13 2020-11-13 单元测试代码结构自动解析与路径分析方法
CN202011267313.5 2020-11-13

Publications (1)

Publication Number Publication Date
WO2022100447A1 true WO2022100447A1 (zh) 2022-05-19

Family

ID=74583804

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/CN2021/127039 WO2022100447A1 (zh) 2020-11-13 2021-10-28 单元测试代码结构自动解析与路径分析方法

Country Status (3)

Country Link
US (1) US20230185703A1 (zh)
CN (1) CN112380120B (zh)
WO (1) WO2022100447A1 (zh)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115080448A (zh) * 2022-07-27 2022-09-20 北京航空航天大学 一种软件代码不可达路径自动检测的方法和装置

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112380120B (zh) * 2020-11-13 2022-06-10 华南理工大学 单元测试代码结构自动解析与路径分析方法

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN103714000A (zh) * 2013-12-18 2014-04-09 杭州电子科技大学 一种面向敏感区域的嵌入式软件测试用例生成方法
US20170220455A1 (en) * 2016-01-29 2017-08-03 Mentor Graphics Corporation Test case generation using a constraint graph solver
CN110046089A (zh) * 2019-03-01 2019-07-23 华南师范大学 一种基于路径覆盖充分性准则的智能合约测试方法
CN110377493A (zh) * 2018-04-12 2019-10-25 南京慕测信息科技有限公司 一种面向代码可读性的单元测试用例优化方法
CN110399286A (zh) * 2018-04-24 2019-11-01 西安邮电大学 一种基于独立路径的测试数据自动生成方法
CN112380120A (zh) * 2020-11-13 2021-02-19 华南理工大学 单元测试代码结构自动解析与路径分析方法

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US10360004B2 (en) * 2017-02-27 2019-07-23 International Business Machines Corporation Using dynamic information to refine control flow graphs
CN107196858B (zh) * 2017-07-04 2020-06-23 西安理工大学 一种考虑多类型约束的k最短路径求解方法
CN108710575B (zh) * 2018-05-23 2020-11-24 华南理工大学 基于路径覆盖测试用例自动生成的单元测试方法
CN110837892A (zh) * 2019-11-12 2020-02-25 广东外语外贸大学 基于带类型关系路径嵌入的事实溯因推理方法

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN103714000A (zh) * 2013-12-18 2014-04-09 杭州电子科技大学 一种面向敏感区域的嵌入式软件测试用例生成方法
US20170220455A1 (en) * 2016-01-29 2017-08-03 Mentor Graphics Corporation Test case generation using a constraint graph solver
CN110377493A (zh) * 2018-04-12 2019-10-25 南京慕测信息科技有限公司 一种面向代码可读性的单元测试用例优化方法
CN110399286A (zh) * 2018-04-24 2019-11-01 西安邮电大学 一种基于独立路径的测试数据自动生成方法
CN110046089A (zh) * 2019-03-01 2019-07-23 华南师范大学 一种基于路径覆盖充分性准则的智能合约测试方法
CN112380120A (zh) * 2020-11-13 2021-02-19 华南理工大学 单元测试代码结构自动解析与路径分析方法

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115080448A (zh) * 2022-07-27 2022-09-20 北京航空航天大学 一种软件代码不可达路径自动检测的方法和装置

Also Published As

Publication number Publication date
CN112380120A (zh) 2021-02-19
CN112380120B (zh) 2022-06-10
US20230185703A1 (en) 2023-06-15

Similar Documents

Publication Publication Date Title
JP7172435B2 (ja) 抽象コードグラフを用いたソフトウェアの表現
CN109426615A (zh) 过程间的空指针解引用检测方法、系统、设备以及介质
WO2022100447A1 (zh) 单元测试代码结构自动解析与路径分析方法
Zhang et al. Faulttracer: a change impact and regression fault analysis tool for evolving java programs
US20140331203A1 (en) Analysis of source code changes
CN106557413A (zh) 基于代码覆盖率获取测试用例的方法和设备
Sarhan et al. A survey of challenges in spectrum-based software fault localization
Leon et al. Multivariate visualization in observation-based testing
US7539977B1 (en) Automatic bug isolation in computer programming languages
Polo et al. Integrating techniques and tools for testing automation
Biaggi et al. An architectural smells detection tool for c and c++ projects
Padhye et al. Travioli: A dynamic analysis for detecting data-structure traversals
Casias et al. Debugging support for pattern-matching languages and accelerators
Zhao et al. Event handler-based coverage for GUI testing
US11132286B1 (en) Dynamic reordering of test case execution
Delamaro et al. Interface mutation test adequacy criterion: An empirical evaluation
CN104298603A (zh) 一种应用系统版本构建的正确性的检查方法
Zhao et al. A Large-Scale Empirical Study of Real-Life Performance Issues in Open Source Projects
Liang et al. Improving the precision of static analysis: Symbolic execution based on GCC abstract syntax tree
Gligoric et al. Optimizing generation of object graphs in Java PathFinder
Liu et al. Extracting Inline Tests from Unit Tests
Hammes et al. Comparing Id and Haskell in a Monte Carlo photon transport code
Xing et al. Distilling useful clones by contextual differencing
Darvish et al. Guidiva: Automated discovery and validation of state-based gui invariants
Farmer et al. What’s the matter with Kansas Lava?

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 21890974

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 21890974

Country of ref document: EP

Kind code of ref document: A1

32PN Ep: public notification in the ep bulletin as address of the adressee cannot be established

Free format text: NOTING OF LOSS OF RIGHTS PURSUANT TO RULE 112(1) EPC (EPO FORM 1205A DATED 05.09.2023)