CN110096439A - A kind of method for generating test case towards solidity language - Google Patents

Abstract

The invention discloses a method for generating test cases oriented to the solidity language. Aiming at the smart contract program implemented by applying the solidity language, the corresponding control flow graph (CFG) is obtained according to the program, and the control flow graph covers the functions and methods in the smart contract program. According to the program CFG, the definition of the variables existing in the program-using pair (dup) is obtained; in the process of generating test cases, the genetic algorithm is used to speed up the generation of effective test cases. On the other hand, considering the integer overflow security problem existing in solidity, when designing the fitness function of the genetic algorithm, it is emphasized that the test cases cover the definition and use of variables that can cause integer overflow errors, and the implementation of dup related to integer overflow errors The fitness value of the covered test cases will be relatively large. The method of the invention is practicable, and realizes the integer overflow coverage test on the basis of realizing the coverage test of the routine variable operation in the program.

Description

A test case generation method for solidity language

technical field

The invention relates to a method for generating test cases oriented to solidity language, in particular to a method for generating test cases based on data flow testing by applying a genetic algorithm, and belongs to the technical field of software testing.

Background technique

In the past two years, with the continuous development of blockchain technology, digital currency and smart contracts have become the focus of many researches. Among them, Ethereum is one of the typical platforms that support smart contract deployment and compilation, and solidity has become the programming language for smart contracts today. Popular languages. The reason why it is called a smart contract is that its main feature is that it can be automatic or have a certain degree of intelligence. Through pre-defined execution conditions and logic, when the conditions are met, the content of the contract is automatically executed to achieve the desired function; Especially with the help of the decentralization, trustless, and tamper-proof features of the blockchain platform, the advantages of smart contracts are better amplified and have greater application prospects. Therefore, the testing of the solidity language is also a problem that requires further research.

Due to the characteristics of the blockchain platform, smart contracts written in the solidity language cannot be dynamically tested during execution. Therefore, the current testing and analysis of the solidity language mainly focuses on static analysis of the source code. In addition to common programming errors in traditional languages, some unique errors may also be caused by programming defects in solidity language. For solidity language programming, Tsankov et al. developed a program analyzer Securify, which predefines the program into two modes: compliance mode and violation mode, and then obtains language information from the code by analyzing the dependency graph of the contract, through Pre-defined conditions, judging program compliance or violation or warning; based on the error of reentrancy attack, Liu et al. proposed a model ReGuard, which converts the solidity program into the passing language C++ through the intermediate representation, and then passes the obtained C++ The program performs fuzzing iteratively generating random and distinct transactions to find bugs.

As the use of smart contracts becomes more and more widespread, not only in the field of currency transactions, but also in other fields such as the general information industry, and the testing of the solidity language is still in its infancy, so It is necessary to consider the test case generation technology for the overall program testing.

Contents of the invention

Purpose of the invention: Considering the novelty of the solidity language, some serious security errors have occurred during its use; at the same time, as the application fields of smart contracts become wider and wider, some existing static codes On the basis of analysis, general testing of the program is also a requirement. The purpose of the present invention is to provide a solidity language-oriented test case generation method, based on the method of data flow testing, to realize the integrity test of variable operations in the program execution process, and at the same time emphasize the integer overflow error that can be caused during the execution process Tests for variable manipulation.

Technical solution: In order to achieve the above-mentioned purpose of the invention, the present invention adopts the following technical solution:

A test case generation method for solidity language, comprising the following steps:

(1) According to the variable type, flow control statement, function body structure, internal function require and function modifier of the solidity language, analyze the smart contract program to be tested implemented by the solidity language to obtain the corresponding control flow graph CFG;

(2) Traversing each node information according to the CFG graph of step (1), judging whether there is a security problem of integer overflow error in the node used by the uint type variable, if there is, then there will be a node mark of integer overflow error;

(3) Traverse the information of each node according to the CFG graph in step (1), and count the definition-use pairs of all numerical variables in the program, which are recorded as dup, and if the judgment result in step (2) is that there is an integer overflow error, then The definition of the variable that contains the label node in the step (2)-use is counted out, and is recorded as dup';

(4) according to the dup that step (3) counts, for all numerical variables in the program, randomly generate an initial set of test cases that includes several groups of test cases;

(5) The fitness function in the genetic algorithm is designed to select a better test case to drive the algorithm to execute; the fitness value of the test case is the number of dups covered by the test case and the dup's covered by the integer overflow error The ratio of the weighted sum of quantities to the quantity of all dups to the weighted sum of all dup' quantities;

(6) According to the fitness function in step (5) and the execution limit of the algorithm, the fitness value of the initial test case in step (4) is obtained, and the iterative execution of the genetic algorithm is started to obtain the optimal result in the algorithm.

In a preferred embodiment, when analyzing the CFG figure of the program to be tested in the described step (1), consider the use of the address variable in the program, consider the definition of other variables drawn by the address variable; consider require and assert condition judgment in the program For the use of statements, the require statement is treated as an if conditional structure statement; the function modifier is regarded as a form of function call. When encountering a function body, first analyze whether the function uses a function modifier. The function modifier is first transferred to the function modifier, and the connection relationship between nodes is transferred according to the content of the function modifier.

In a preferred embodiment, the step (2) includes the following steps:

(21) Whether there is an integer overflow error in the CFG analysis program obtained according to step (1), specifically: traversing the nodes of the CFG graph, for nodes using uint variables, the use of variables includes performing addition, subtraction, multiplication or division calculations , to determine whether there is a statement node for overflow judgment on the operation result of the corresponding variable before the variable use node, if not, the judgment program will have an integer overflow error;

(22) If there is an integer overflow error, mark the variable operation nodes involved in the integer overflow error in the CFG.

In a preferred embodiment, the step (3) includes the following steps:

(31) According to the CFG diagram, analyze the sentence information node by node, find the definition node of the numerical variable existing in the program;

(32) For the definition node of each variable found in step (31), find all its corresponding use nodes;

(33) In conjunction with steps (31), (32), obtain the definition of the variable that exists in the program-use pair: dup=(d, u, v), calculate its total quantity, be recorded as n; Wherein v represents a certain variable , d represents a definition node of v, u represents a use node of v;

(34) Combining the contents of step (22) and step (31), (32) to obtain the variable definition-use pair that has integer overflow problem, expressed by dup' here, calculate its total quantity, denoted as m, if step (22 ), the result is that there is no integer overflow problem, that is, it is not marked, and the statistical value of m here is 0.

In a preferred embodiment, in the step (4), an initial test case set containing 4 groups of test cases is randomly generated for all numerical variables in the program.

In a preferred embodiment, in the step (5), the fitness function formula Where p _i represents the number of dups covered by the i-th test case, q _i represents the number of dups involving integer overflow errors covered by the i-th test case, n represents the number of all dups in the program, m represents all the dups involved in the program The number of dup's to integer overflow errors, ε is the weight parameter, 0<ε<1.

In a preferred embodiment, in the step (6), the setting of the algorithm execution limit includes two parts: (1) the number of iterations of the genetic algorithm, if the highest algebraic limit is reached, the fitness value has not yet reached 1, and it ends; (2) Within the upper limit of genetic algebra, if the fitness value reaches 1, save the generated results of the current test case, and then proceed to the next generation of experiments. If the fitness value of the experimental results is smaller than that of the parent generation, then end and take the results of the previous generation.

In a preferred embodiment, the step (6) includes the following steps:

(61) Calculation of individual fitness value in the population: For each individual generated, that is, each test case, put the corresponding test data into the program for execution, and calculate the covered dup by inserting the source program in advance Quantity, denoted as p, and covering dup' quantity, denoted as q, when counting the value of q, the prerequisite is that in the current individual execution state, the operation of the variable satisfies the overflow condition, and it is recorded as an integer overflow error An effective coverage of , and calculate the individual fitness value according to the fitness function;

(62) Genetic algorithm iterative execution, select the optimal result in the algorithm: according to the roulette wheel selection method, uniform crossover operator and mutation in the genetic algorithm, iteratively execute the genetic algorithm. (61), until the algorithm execution limit is reached, the algorithm result is finally obtained.

Beneficial effects: the test case generation method based on data flow test oriented to solidity language provided by the present invention takes into account that many function calls are involved in program execution, and in the process of function execution call, the definition and use of variables are different. It is the key link, so the method based on data flow testing is adopted to analyze the state changes according to the definition and usage of variables in the program. While realizing the overall test of variable operations in the process of program execution, the test of variable operations that can cause integer overflow errors in the process of execution is emphasized. The premise of this operation is to check whether the operations that cause integer overflow have been completed through control flow analysis. The overflow judgment is carried out to determine whether the problem of integer overflow will occur during the execution of the program. Compared with the prior art, the present invention proposes a feasible algorithm in the field of solidity language test case generation. On the basis of realizing the coverage test of conventional variable operations in the program, it further considers the Coverage tests for badly problematic variable operations with integer overflow errors. And the genetic algorithm adopted in the present invention optimizes the test case generation process, and can generate better test cases in a short time.

Description of drawings

Fig. 1 is an overall step diagram of an embodiment of the present invention;

Fig. 2 is a flow chart of the method of the embodiment of the present invention.

Detailed ways

Below in conjunction with specific embodiment, further illustrate the present invention, should be understood that these embodiments are only used to illustrate the present invention and are not intended to limit the scope of the present invention, after having read the present invention, those skilled in the art will understand various equivalent forms of the present invention All modifications fall within the scope defined by the appended claims of the present application.

As shown in Figure 1, a kind of solidity language-oriented test case generation method provided by the embodiment of the present invention comprises the following steps:

Step S1: CFG drawing of the program to be tested. According to the variable type of solidity language (especially address type address and unsigned integer uint); flow control statements including if-else, while, for, etc.; function body structure defined by keyword function; unique internal function require and function The use of the modifier Function Modifier etc. to get accurate CFG. This step mainly pays attention to the following when drawing the CFG diagram: (1) When a conditional judgment statement such as require (or assert) is encountered in the program (generally within a function), treat require() as an if judgment structure, and use The statement that needs to be judged is treated as a conditional node. When the condition in () is met, continue to execute the content below the statement, if the condition is not met, jump out of the function directly. (2) The call between functions existing in the program should be processed. For statement nodes that have function method calls, it is necessary to realize the call to the function through the program CFG graph, obtain the correct execution sequence, and correctly return the return result of the called function to the call node; (3) correctly handle the call of the function modifier, and It is handled as a general function call. If the current function needs to call the function modifier, the statement node of the function modifier must be called before the statement node in the function body. In CFG, the connection call of the related nodes should be realized according to the order of statement execution .

Step S2: Integer overflow error analysis. Traversing the node information according to the CFG graph in step S1, before counting the variable information, first analyze whether the program has an integer overflow security problem, if there is an integer overflow, there will be an integer overflow node mark;

Step S3: The definition of the program variable uses pair collection. According to the CFG traversal node in step S1, the definition-use pairs of all variables in the program are counted, which is recorded as dup, and if the analysis result in step S2 shows that there is an integer overflow error, there will be a definition-use of the variable that exists in the marked node For the statistics, it is recorded as dup';

Step S4: Initial test case set generation. According to the dup counted in step S3, first randomly generate an initial test case set containing 4 groups of test cases for all variables in the program;

Step S5: Design of fitness function and definition of algorithm execution boundary. Design the fitness function in the genetic algorithm to select the superior test case to drive the algorithm execution; and define the genetic algorithm execution boundary, balance the coverage and execution time, and assist the algorithm execution;

Step S6: Execute the genetic algorithm to obtain the optimal test case. According to the fitness function in step S5, the fitness value of the initial test case (population) in step S4 is obtained, enters the genetic algorithm execution stage, and obtains the optimal result in the algorithm.

Fig. 2 is the detailed steps of a kind of solidity-oriented language-based test case generation method based on data flow testing of the embodiment of the present invention, specifically as follows: in step S1, according to the program to be tested, the corresponding control flow diagram will be obtained, and the specific steps are:

Step 101: Draw the CFG of a given program. When drawing the control flow graph of a program written in solidity, first consider its control structure statements: general ones include if-else, while, do-while, for, break, continue, return, ? : (ternary operator); there are no switch and goto control structure statements in solidity. In addition, pay attention to the use of the require statement in the program. When encountering a require statement, treat it as an if selection control structure. If the condition is met, it will go to the next statement. If the condition is not met, exit the currently executing function. And the use of the unique function modifier in the language, when a function modifier is used in a function, the function modifier is treated as a function call, and the content of the function modifier is executed first;

Step 102: In solidity, there may be multiple function methods (the keyword is function) inside a contract program. Therefore, for all statements with function calls in a given program, the relevant information of the vertex node of the statement is processed It is also necessary to correctly define the call of the function involved and the return relationship of the called function.

Step 103: Solidity includes a modifier function modifier attribute, and a function can be modified by calling the function modifier. Therefore, in the process of generating the control flow graph, it is necessary to correctly handle the existing call to the function modifier, and treat it as a general function call——if the current function calls the function modifier, it should be executed before the statement node in the function body The statement node that calls the function modifier first.

In step S2, analyze whether there is an integer overflow error in the program according to the program CFG, and when there is an integer overflow error, mark the nodes involved in the overflow error, and the specific steps are as follows:

Step 201: Operations on variables of uint type (the minimum value of this type of variable is 0) in the program may cause integer overflow, especially for short-bit variables such as uint8, so arithmetic operations are performed on such variables Before the operation (addition, subtraction, multiplication, and division), a variable overflow judgment must be performed. If the program does not have an overflow judgment, there will be an integer overflow problem; therefore, the program CFG in step 1 analyzes each node sequentially from the beginning node. If there is a node of uint type variable operation operation, it is judged whether an integer overflow judgment has been performed on the operation before this node, if there is no overflow judgment language node, it is judged that the program has an integer overflow problem;

Step 202: If after analysis, the program to be tested has integer overflow, then make a special mark on the variable operation nodes involved in causing integer overflow errors in the CFG.

In step S3, according to the CFG of the program, the definitions of all the variables that exist in the program are analyzed - using the pair dup, the specific steps are as follows:

Step 301: For each node in the CFG, identify the vertex node that contains the variable definition by vertex node in the forward order (for example, there is a statement at the vertex node ④ place is sum=a+b, then vertex ④ contains the pair variable The definition of sum is a definition node of sum), a variable may be defined at multiple nodes, in the process of finding the definition node def, it should be noted that a special marked node is made in step 202, if it is a variable definition node, it is still Treated as a special node;

Step 302: For each definition node of each variable in step 301, search for all its corresponding use nodes (for example, there is a statement at a vertex node ④ place is sum=a+b, then vertex ④ contains pair variable a and The use of variable b is a use node of both a and b), similarly, there may be multiple use nodes use for a variable, when looking for the use node use, pay attention to the special marked node in step 202, if it is a variable The used node is still treated as a special node;

Step 303: Combining step 301 and step 302, the definition-use pairs of all variables in the program will be obtained. Here, the following expression dup=(d, u, v) is used, wherein v represents a certain variable, and d represents a certain value of v A definition node, u represents a use node of v. For the same variable, there may be multiple definition nodes and multiple use nodes, so there can be multiple definition and use pairs of variables, and the sum of the number of dups that appear (denoted as n);

Step 304: Combining the contents of Step 202 and Steps 301-302 to obtain the variable definition-use pair with integer overflow problem, here it is represented by dup', which is used to distinguish the definition and use of general variables and variables that can cause integer overflow, and the calculation occurs The sum of the numbers of dup' (denoted as m), if the result in step 202 is that there is no integer overflow, that is, no mark is made, then the statistical value of m here is 0.

In step S4, an initial test case (primary population) is generated, and the specific steps are as follows:

Step 401: For the population size in the genetic algorithm (there are several groups of test cases, each test case includes a test input of all variables in the program) setting problem, considering the speed of fitness value calculation, the ideal test case in the genetic algorithm The generation efficiency, combined with the parameter selection and experimental analysis in the relevant test case generation literature, and the use of the crossover operator in the genetic algorithm, it is finally determined that the population size is 4 is more appropriate;

Step 402: Regarding the initial test case generation method, a random test random generation method is adopted, and a random number is randomly generated according to the variables existing in the program as the variable test input.

Different from object-oriented programming languages (such as java), there are some security issues that can cause serious problems in solidity, and mainly relate to integer overflow among the present invention, and the appearance of this problem can cause serious consequence in concrete use environment, this This prompts this point to be emphasized during program testing. Combined with the specific cause of the error, this problem can be obtained through the analysis of the program execution sequence in step S2; therefore, in the process of applying the genetic algorithm, it is necessary to design a suitable fitness function to obtain the fitness value of the test case to find the optimal Test cases, on the other hand, constrain the execution of the genetic algorithm in order to find an optimal solution to the algorithm in a reasonable amount of time. In step S5, the genetic algorithm fitness function design and algorithm execution upper limit description, the specific steps are as follows:

Step 501: Set the parameter ε, where 0<ε<1, the function of ε here is to increase the weight of related variable operations that can cause integer overflow, and the value of ε can be adjusted in a small range through some pre-experiments, and through analysis and testing When the use case tends to be optimal, the number of iterations of the genetic algorithm and the convergence of the overall fitness value are used to obtain the ε value, which is used for subsequent experiments;

Step 502: based on the goal of the data flow coverage test (whether the current test case can cover the path between the definition of each variable in the program and the use of the variable reached by the definition) and the basic criterion (the test case's in-program The definition of all variables - the coverage of the use path determines the quality of the test case), construct the fitness function Where i represents the i-th test case, p _i represents the number of dups covered by the i-th test case, q _i represents the number of dups involving integer overflow errors covered by the i-th test case, n represents the number of all dups in the program The number, m represents the number of dup's involving integer overflow errors in the program;

Step 503: The end condition of the algorithm execution is described through the following two parts: (1) In order to achieve the goal of being able to execute within a limited time, set a reasonable number of iterations of the genetic algorithm. If the highest algebraic limit is reached, even if the fitness value (2) If the fitness value reaches 1 within the upper limit of the genetic algebra, in order to obtain a better test case, the algorithm will continue to execute the next generation of genetic calculations, and save the current test case generation results at the same time , if the fitness value of the test results of the next generation does not reach 1, the algorithm ends, and the result of the previous generation is taken; otherwise, there is a test case with a fitness value of 1, the algorithm ends, and the execution result of the last generation is taken.

In step S6, the genetic algorithm is executed to obtain the optimal test case in the algorithm. The specific steps are as follows (note: during the execution of the genetic algorithm, "individual" is used to represent each test case):

Step 601: According to the test input value of the variable in each individual in the population, execute each statement node according to the CFG sequence of the program. For the current individual, first calculate the number of dups covered by it (denoted as p), and the number of covered dup's (denoted as q), when counting the value of q, it should be noted that the precondition should be satisfied: when the current individual is brought into the execution state, the use or definition of the variable satisfies the overflow condition (that is, the test value brought into the variable Afterwards, save the intermediate results of corresponding node operations for comparison and analysis, and the analysis result is overflow), the individual can be recorded as an effective coverage of integer overflow operations, if there is no integer overflow in step 201, and there is no marked node, If there is no marked dup' in step 202, the q statistical value here is 0, and the fitness value of each individual is calculated according to the fitness function in step 502, and the execution of each subsequent generation of genetic algorithm first calculates the new The fitness value of each individual in the generated population;

Step 602: In the present invention, the selection operator of the genetic algorithm adopts a roulette selection operator, specifically: the probability of an individual being selected is proportional to the size of its fitness value, and the probability of each individual being selected can be expressed as Among them, M represents the population size (that is, the number of test cases), and F _i represents the fitness value of the i-th test case;

Step 603: In the present invention, the basic principle of the crossover operator used in the genetic algorithm part is the same as that of the uniform crossover operator, but some changes have been made on the principle of the traditional uniform crossover operator, specifically: the crossover link takes two individuals as one Group, each variable in the two paired individuals in the group is exchanged with the same probability to form two new individuals, and finally four new individuals can be obtained;

Step 604: In the present invention, the mutation operator used in the genetic algorithm part is modified on the basis of the basic bit mutation of the traditional genetic algorithm, specifically: for the individuals obtained after the crossover operator, randomly designate one of the individuals Or several variables are transformed with mutation probability P _m ;

Step 605: After steps 601-604, the genetic algorithm will automatically generate the next generation population;

Step 606: Under the constraints of the algorithm execution end condition in step 503, iteratively execute steps 601-605, and the finally obtained test case can be regarded as the optimal solution in the algorithm.

Claims (8)

1. a kind of method for generating test case towards solidity language, which comprises the steps of:

(1) according to the types of variables of solidity language, control flow statement, function body structure, intrinsic function require and The use of function modifier is analyzed to obtain corresponding control to the intelligent contract program to be tested that solidity language is realized Flow graph CFG；

(2) each nodal information is traversed according to the CFG of step (1) figure, there are the nodes of uint type variable uses whether there is for judgement The safety issue of Integer overflow, and if it exists, the vertex ticks of Integer overflow then will be present；

(3) each nodal information is traversed according to the CFG of step (1) figure, counts definition-use of all numeric type variables in program It is right, it is denoted as dup, and if judging result is that will include the label section in step (2) there are Integer overflow in step (2) The definition-use pair of the existing variable of point comes out, and is denoted as dup '；

(4) dup counted according to step (3), if for all numeric type variables in program generate at random it is initial comprising The test use cases of dry group test case；

(5) fitness function in genetic algorithm is designed for choosing preferably test case to drive algorithm to execute；Wherein survey The fitness value of example on probation is the quantity of the dup of test case covering and the dup ' quantity for being related to Integer overflow of covering Weighted sum and all dup quantity and all dup ' quantity weighted sums ratio；

(6) according to the execution boundary of fitness function and algorithm in step (5), initial test case in step (4) is acquired Fitness value, start genetic algorithm iteration execute, obtain optimal result in algorithm.

2. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly in (1) when the CFG figure of analysis program to be tested, consider that the use of address type variable in program, consideration are drawn by address variable The definition of its dependent variable；Consider that require and assert condition judges the use of sentence in program, using require sentence as One if construction of condition sentence is handled；A kind of form that function modifier is regarded as to function call, when encountering function body, It analyzes whether the function has used function modifier first, function modifier is first transferred to if having used function modifier, according to Function modifier content carries out the connection relationship transfer between node.

3. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly include the following steps: in (2)

(21) it whether there is Integer overflow in the CFG analysis program obtained according to step (1), specifically: traversal CFG figure section Point, for there are the nodes of uint type variable uses, wherein variable uses include executing add, subtract, multiplying or except calculating, judging becoming Amount determines journey if not having using whether having the sentence node for overflow judgement to relevant variable operating result before node Sequence will appear Integer overflow；

(22) Integer overflow if it exists marks the variable running node for being related to causing Integer overflow in CFG Note.

4. the method for generating test case according to claim 3 towards solidity language, which is characterized in that the step Suddenly include the following steps: in (3)

(31) schemed according to CFG, node by node anolytic sentence information, find the definition node of numeric type variable present in program；

(32) it for the definition node of each variable found in step (31), finds its and corresponding all uses node；

(33) step (31), (32) are combined, the definition-use pair of variable present in program: dup=(d, u, v) is obtained, are calculated Its total quantity, is denoted as n；Wherein v indicates that a certain variable, d indicate a certain definition node of v, and u indicates that a certain of v uses node；

(34) content of step (22) and step (31), (32) is combined to obtain the variable-definition-use that there are problems that integer overflow It is right, it is indicated here with dup ', calculates its total quantity, be denoted as m, if result is not have integer overflow problem in step (22), i.e., not It makes marks, then m statistical value is 0 herein.

5. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly the initial test use cases comprising 4 groups of test cases are generated in (4) at random for all numeric type variables in program.

6. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly in (5), fitness function formulaWherein p_iIndicate i-th of test case covering The quantity of dup, q_iIndicate the dup ' quantity for being related to Integer overflow of i-th of test case covering, institute in n representation program There is the quantity of dup, all dup ' quantity for being related to Integer overflow in m representation program, ε is weight parameter, 0 < ε < 1.

7. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly in (6), the setting that algorithm executes boundary includes two parts: (1) genetic algorithm the number of iterations, if reaching the limitation of highest algebra, Fitness value is still not up to 1, also terminates；(2) in the genetic algebra upper limit, current test is saved if fitness value reaches 1 and is used Example generates as a result, carry out next-generation experiment again, if the fitness value of experimental result is small compared with parent, terminates, takes previous generation result.

8. the method for generating test case according to claim 1 towards solidity language, which is characterized in that the step Suddenly include the following steps: in (6)

(61) ideal adaptation angle value calculates in population: for each individual of generation, i.e., each test case, by corresponding test Data are put into program and execute, and the dup quantity of its covering is calculated by way of carrying out pitching pile to source program in advance, is denoted as p, with And covering dup ' quantity, it is denoted as q, when counting the value of q, precondition is the behaviour of variable under current individual execution state Work meets overflow condition, is just denoted as primary effective covering to Integer overflow, according to fitness function, calculates individual Fitness value；

(62) genetic algorithm iteration executes, optimal result in Algorithms of Selecting: according to the roulette wheel selection, uniformly in genetic algorithm Crossover operator and variation execute iteration and execute genetic algorithm, and genetic algorithm executes fitness value calculation all such as step each time (61), until executing boundary until reaching algorithm, arithmetic result is finally obtained.