CN110096439B - Test case generation method for solidity language - Google Patents

Abstract

The invention discloses a method for generating a test case facing to a solidness language, aiming at an intelligent contract program realized by applying the solidity language, a corresponding Control Flow Graph (CFG) is obtained according to the program, and the control flow graph covers calling information among function methods in the intelligent contract program; deriving from the program CFG definition-use pairs (dup) of variables present in the program; in the process of generating the test case, a genetic algorithm is applied to accelerate the generation speed of the effective test case. On the other hand, considering the problem of integer overflow safety existing in the solid, when the fitness function of the genetic algorithm is designed, the definition and the use of variables which can cause integer overflow errors by the test cases are emphasized to realize coverage, and the fitness value of the test cases which cover dup related to the integer overflow errors is relatively large. The method is feasible, and realizes the integer overflow coverage test on the basis of realizing the coverage test of the conventional variable operation in the program.

Description

A Test Case Generation Method for Solidity Language

technical field

The invention relates to a test case generation method oriented to solidity language, in particular to a test case generation method using genetic algorithm and based on data flow testing, 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 the deployment and compilation of smart contracts, and solidity has become the author of smart contracts. popular languages. The reason why it is called a smart contract is that its main feature is that it can be automatic or possess a certain intelligence. Through pre-defined execution conditions and logic, when the conditions are met, the contract content is automatically executed to achieve the desired function; In particular, with the help of the decentralization, trustlessness, and tamper resistance 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 needs more in-depth study.

Due to the characteristics of the blockchain platform, smart contracts written in the solidity language cannot complete dynamic testing during the execution process. Therefore, the current testing analysis of the solidity language mainly focuses on the static analysis of the source code. In addition to the common program errors in traditional languages, some unique errors may also be caused in solidity languages due to programming defects. 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 Predefined conditions, judge program compliance or violation or warning; based on the error of reentrancy attack, Liu et al. proposed a model ReGuard, which converts solidity programs into language C++ through intermediate representation, and then passes on the obtained C++ The program performs fuzzing iterations to generate random and distinct transactions to find bugs.

As the use of smart contracts becomes more and more extensive, it will be widely used not only in the field of currency transactions, but also in other general information industries and other fields, and the test for solidity language is still in its infancy, so It is necessary to take into account the test case generation techniques for the overall testing of the program.

SUMMARY OF THE INVENTION

Purpose of the invention: Considering the novelty of the solidity language, and some serious security errors have occurred in the process of use; at the same time, with the wider application of smart contracts, 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 test case generation method oriented to solidity language, based on the method of data flow test, to realize the integrity test of variable operation in the process of program execution, and at the same time to emphasize the problem of integer overflow errors in the execution process. Tests for variable manipulation.

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

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

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

(2) traverse the information of each node according to the CFG graph of step (1), and judge whether there is a security problem of integer overflow error in the node used by the uint type variable, and if so, there will be a node mark with an integer overflow error;

(3) Traverse the information of each node according to the CFG graph of 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 Count the definition-use pairs of the variables including the existence of the marked node in step (2), and denote it as dup';

(4) According to the dup counted in step (3), randomly generate an initial test case set containing several groups of test cases for all numerical variables in the program;

(5) The fitness function in the genetic algorithm is designed to select the optimal test case to drive the execution of the algorithm; the fitness value of the test case is the number of dups covered by the test case and the covered dups involving integer overflow errors. The ratio of the weighted sum of the number to the number of all dups and the weighted sum of the number of all dup's;

(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 diagram of the program to be tested in the step (1), consider the use of the address variable in the program, and consider the definition of other variables derived from the address variable; consider the require and assert conditions in the program to judge The use of the statement, 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, if used 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, and for the nodes where the uint variable is used, the variable use includes performing addition, subtraction, multiplication or division calculation , judging whether there is a statement node for overflow judgment on the corresponding variable operation result 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 node 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 graph, analyze the statement information node by node, and 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 use nodes corresponding to it;

(33) Combining steps (31) and (32), the definition of the variable existing in the program is obtained-use pair: dup=(d, u, v), calculate the total number, and denote it as n; where v represents a variable , d represents a definition node of v, and u represents a usage node of v;

(34) Combining the contents of step (22) and steps (31) and (32), the variable definition-use pair with integer overflow problem is obtained, which is represented by dup' here, and the total number is calculated, which is recorded as m. If step (22) ), the result is that there is no integer overflow problem, that is, it is not marked, so the m statistic value here is 0.

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

其中p_i表示第i个测试用例覆盖的dup的数量，q_i表示第i个测试用例覆盖的涉及到整数溢出错误的dup’数量，n表示程序中所有dup的数量，m表示程序中所有涉及到整数溢出错误的dup’数量，ε为权重参数，0<ε<1。In a preferred embodiment, in the step (5), the fitness function formula

where pi represents the number of dups covered by the _ith test case, qi represents the number of dup's covered by the _ith test case involving integer overflow errors, n represents the number of all dups in the program, and 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, and the fitness value has not yet reached 1, it will also end; (2) Within the upper limit of the genetic algebra, if the fitness value reaches 1, the current test case generation result will be saved, and then the next generation experiment will be performed. If the fitness value of the experimental result is smaller than that of the parent generation, it will end, and the result of the previous generation will be taken.

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 pre-instrumenting the source program. The number, denoted as p, and the number of covered dup's, denoted as q, when the value of q is counted, the precondition is that in the current individual execution state, the operation of the variable satisfies the overflow condition, and then it is recorded as an integer overflow error An effective coverage of , according to the fitness function, calculate the individual fitness value;

(62) Iteratively execute the genetic algorithm, and select the optimal result in the algorithm: execute the genetic algorithm iteratively according to the roulette selection method, the uniform crossover operator and the mutation in the genetic algorithm, and each time the genetic algorithm performs the fitness value calculation steps (61), until the algorithm execution limit is reached, and finally the algorithm result is obtained.

Beneficial effect: The method for generating test cases based on data flow testing oriented to solidity language provided by the present invention, considering that many function calls are involved in program execution, and in the process of function execution and invocation, the definition and use of variables are different. is its key link, so the method based on data flow test is adopted to analyze the change of state according to the definition and usage of variables in the program. While implementing the overall testing of variable operations during program execution, it also emphasizes the testing of variable operations that can cause integer overflow errors during execution. The premise of this operation is to analyze whether the integer overflow operation has been The overflow judgment is carried out to judge whether the problem of integer overflow occurs in the execution of the program. Compared with the prior art, the present invention proposes a feasible algorithm in the field of test case generation oriented to solidity language. Coverage testing of variable operations for serious problems with integer overflow errors. And the genetic algorithm adopted in the present invention optimizes the test case generation process, and can generate a better test case in a short time.

Description of drawings

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

FIG. 2 is a flowchart of a method according to an embodiment of the present invention.

Detailed ways

Below in conjunction with specific embodiments, the present invention will be further illustrated, and it should be understood that these embodiments are only used to illustrate the present invention and not to limit the scope of the present invention. The modifications all fall within the scope defined by the appended claims of this application.

As shown in FIG. 1 , a method for generating a test case for solidity language provided by an embodiment of the present invention includes the following steps:

Step S1: CFG drawing of the program to be tested. According to the variable type of solidity language (especially including address type address and unsigned integer type uint); flow control statements including if-else, while, for, etc.; define function body structure through keyword function; unique internal function require and function Use of modifiers Function Modifier etc to get accurate CFG. In this step, when drawing the CFG diagram, pay attention to the following: (1) When a conditional judgment statement such as require (or assert) is encountered in the program (usually within a function), require() is regarded as an if judgment structure, and the The statement that needs to be judged is processed as a conditional node. When the condition in () is satisfied, continue to execute the content below the statement, if the condition is not satisfied, jump out of the function directly. (2) The calls between functions existing in the program should be processed. For the statement node with function method call, the function call should be realized through the program CFG graph, the correct execution order should be obtained, and the return result of the called function should be correctly returned to the calling node; (3) Correctly handle the call of the function modifier, put It is processed 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. .

Step S2: Integer overflow error analysis. According to the CFG graph of step S1 traversing the node information, before statistical 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: Definition of program variables using pair collection. According to the CFG traversal node in step S1, the definition-use pairs of all variables in the program are counted, and denoted as dup, and if the analysis result in step S2 is that there is an integer overflow error, there will be a variable definition-use pair that exists in the marked node. For statistics, it is recorded as dup';

Step S4: an initial test case set is generated. 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: fitness function design and algorithm execution limit definition. Design the fitness function in the genetic algorithm to select the best test case to drive the execution of the algorithm; and define the execution limit of the genetic algorithm, balance the coverage and execution time, and assist the execution of the algorithm;

Step S6: The genetic algorithm is executed 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, and the genetic algorithm execution stage is entered to obtain the optimal result in the algorithm.

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

Step 101: Draw the CFG of a given program. When drawing the control flow graph of the program written by Solidity, first consider its control structure statements: common ones are 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 the require statement is encountered, it is treated as an if selection control structure. When the condition is satisfied, the next statement is reached. When the condition is not satisfied, the currently executing function is exited. And the use of the unique function modifier in the language, when a function modifier is used in a function, the function modifier is processed as a function call, and the content of the function modifier is executed first;

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

Step 103: Solidity includes the modifier function modifier attribute, and a function can implement the modification effect of the function 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 of the function modifier is called first.

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

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

Step 202 : If the program to be tested has an integer overflow after analysis, special mark is made on the variable operation node involved in the integer overflow error in the CFG.

In step S3, the definition-use pair dup of all variables existing in the program is analyzed according to the CFG of the program, and the specific steps are as follows:

Step 301: For each node in the CFG, identify the vertex node containing the variable definition by vertex node in the forward order (for example, if there is a vertex node ④ where the statement is sum=a+b, then the vertex ④ contains a pair of variables. The definition of sum is a definition node of sum), a variable may be defined at multiple nodes, in the process of searching for the definition node def, pay attention to the special marked node in step 202, if it is the definition node of the variable, still Treated as a special node;

Step 302: For each definition node of each variable in step 301, look for all corresponding use nodes (for example, if there is a vertex node ④ where the statement is sum=a+b, then vertex ④ contains a pair of variables a and The use of variable b is both a and a use node of b). Similarly, a variable may have multiple use nodes use. When looking for 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, dup=(d, u, v) is expressed as follows, where v represents a variable, and d represents a certain variable of v. A definition node, u represents a certain usage node of v. For the same variable, there may be multiple definition nodes and multiple use nodes, so the definition and use pairs of the variable can be multiple, and the sum of the number of dup that appears (denoted as n) is calculated;

Step 304: Combining the contents of Step 202 and Steps 301-302 to obtain a variable definition-use pair that has an integer overflow problem, which is represented by dup' here, it is used to distinguish the definition and use of a general variable and a variable that can cause an integer overflow, and the calculation occurs The sum of the number of dup's (denoted as m), if the result in step 202 is that there is no integer overflow, that is, it is not marked, 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 problem of setting the population size in the genetic algorithm (there are several groups of test cases, each test case contains a test input for all variables in the program), considering the speed of the calculation of the fitness value, the ideal test case in the genetic algorithm Combined with the parameter selection and experimental analysis in the relevant test case generation literature, and at the same time with the use of the crossover operator in the genetic algorithm, it is more appropriate to finally determine the population size to be 4;

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 a variable existing in the program as a test input of the variable.

Different from object-oriented programming languages (such as java), solidity has some security problems that can cause serious problems. The present invention mainly involves integer overflow. The occurrence of this problem will cause serious consequences in a specific use environment. This is why it should be emphasized in the process of program testing. Combined with the specific cause of the error, this problem can be analyzed by the program execution sequence in step S2; therefore, in the process of applying the genetic algorithm, it is necessary to design an appropriate fitness function to obtain the fitness value of the test case to find the optimal fitness value. The test case, on the other hand, is to limit the execution of the genetic algorithm in order to find a better solution to the algorithm in a reasonable time. In step S5, the genetic algorithm fitness function design and the algorithm execution upper limit description, the specific steps are as follows:

Step 501: Set the parameter ε, where 0<ε<1, the role of ε here is to increase the weight of related variable operations that can lead to integer overflow. Through some pre-experiments, the value of ε can be adjusted in a small range, and the analysis test can be passed. 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 for subsequent experiments;

其中i表示第i个测试用例，p_i表示第i个测试用例覆盖的dup的数量，q_i表示第i个测试用例覆盖的涉及到整数溢出错误的dup’数量，n表示程序中所有dup的数量，m表示程序中所有涉及到整数溢出错误的dup’数量；Step 502: Cover the test target based on the data flow (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 criteria (the test case's internal reference to the 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 ith test case, pi represents the number of dups covered by the ith test case, q _i represents the number of dup's covered by the ith test case involving integer overflow errors, and n represents the number of dups covered by the ith test case. The number, m represents the number of dup's involved in integer overflow errors in the program;

Step 503: The execution end condition of the algorithm is explained through the following two parts: (1) In order to achieve the goal that can be executed in 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) Within the upper limit of genetic algebra, if the fitness value reaches 1, in order to obtain better test cases, the algorithm will continue to execute the next generation of genetic calculations, while saving the current test case generation results , if the fitness value of the next generation experimental result 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 within the algorithm, and the specific steps are as follows (Note: in the execution process 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' (denoted as q), when counting the value of q, it should be noted that its preconditions should be satisfied: in the state of bringing the current individual into the execution state, the use or definition of the variable satisfies the overflow condition (that is, the test value brought into the variable). After saving the intermediate results of the corresponding node operations for comparative analysis, and the analysis result is overflow), the individual can be recorded as an effective coverage of the integer overflow operation. If there is no integer overflow in step 201, there is no marked node, There is no marked dup' in step 202, the q statistic 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 is calculated first. The fitness value of each individual in the generated population;

其中M表示种群大小(即测试用例的数量)，F_i表示第i个测试用例的适应度值；Step 602: In the present invention, the selection operator of the genetic algorithm adopts the 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:

where M represents the population size (that is, the number of test cases), and F _i represents the fitness value of the ith test case;

Step 603: In the present invention, the basic principle of the crossover operator used in the genetic algorithm is the same as that of the uniform crossover operator, but some changes have been made in the principle of the traditional uniform crossover operator. 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 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 the probability of mutation 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 end condition of the algorithm execution 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 method for generating a test case facing to a language is characterized by comprising the following steps:

(1) analyzing an intelligent contract program to be tested realized by the solidity language according to the variable type, the flow control statement, the function body structure, the internal function requirer and the use of the function modifier of the solidity language to obtain a corresponding control flow graph CFG;

(2) traversing each node information according to the CFG graph in the step (1), judging whether the node used by the agent type variable has the safety problem of the integer overflow error, and if so, marking the node with the integer overflow error;

(3) traversing each node information according to the CFG graph in the step (1), counting definition-use pairs of all numerical variables in the program, and recording the definition-use pairs as dup, and counting the definition-use pairs of the variables including the marked nodes in the step (2) if the judgment result in the step (2) is that an integer overflow error exists, and recording the definition-use pairs as dup';

(4) randomly generating an initial test case set containing a plurality of groups of test cases aiming at all numerical variables in the program according to the dup counted in the step (3); the group number of the test cases is determined according to the size of the population in the genetic algorithm;

(5) designing a fitness function in the genetic algorithm for selecting a better test case to drive the algorithm to execute; the fitness value of the test case is the ratio of the weighted sum of the number of dups covered by the test case and the number of covered dup 'related to integer overflow errors to the weighted sum of the number of all dups and the number of all dup';

(6) and (4) according to the fitness function in the step (5) and the execution limit of the algorithm, solving the fitness value of the initial test case in the step (4), and starting iterative execution of the genetic algorithm to obtain an optimal result in the algorithm.

2. The solidity language-oriented test case generation method according to claim 1, wherein, when analyzing the CFG diagram of the program to be tested in step (1), the use of an address type variable in the program is considered, and the definition of an unsigned integer variable derived from the address variable is considered; considering the use of a require and alert condition judgment statement in a program, and processing the require statement as an if condition structure statement; the function modifier is regarded as a form of function call, when a function body is encountered, whether the function uses the function modifier is firstly analyzed, if the function modifier is used, the function modifier is firstly transferred, and the connection relation among nodes is transferred according to the content of the function modifier.

3. The solidity language-oriented test case generation method according to claim 1, wherein the step (2) includes the following steps:

(21) according to whether an integer overflow error exists in the CFG analysis program obtained in the step (1), the method specifically comprises the following steps: traversing CFG graph nodes, and judging whether statement nodes for performing overflow judgment on corresponding variable operation results exist before the variable use nodes or not for the nodes with the agent type variable use, wherein the variable use comprises addition, subtraction, multiplication or division calculation, and if not, judging that an integer overflow error occurs in a program;

(22) if the integer overflow error exists, marking the variable operation nodes which are involved in the CFG and cause the integer overflow error.

4. The solidity language-oriented test case generation method according to claim 3, wherein the step (3) includes the following steps:

(31) analyzing the statement information node by node according to the CFG graph, and finding out definition nodes of numerical variables in the program;

(32) finding all corresponding use nodes of the definition nodes of each variable found in the step (31);

(33) in connection with steps (31), (32), the definition-use pairs of the variables present in the program are obtained: d, calculating the total number of dup and recording the total number as n; wherein v represents a variable, d represents a defined node of v, and u represents a used node of v;

(34) and (3) combining the contents of the step (22) and the steps (31) and (32) to obtain a variable definition-use pair with the integer overflow problem, wherein the variable definition-use pair is denoted by dup', the total number of the variable definition-use pair is calculated and is marked as m, and if the result in the step (22) is that no integer overflow problem exists, namely the integer overflow problem is not marked, the statistical value of m is 0.

5. The method according to claim 1, wherein the step (4) randomly generates an initial test case set containing 4 groups of test cases for all the numerical variables in the program.

6. The method for generating relevance language-oriented test cases according to claim 1, wherein in the step (5), the fitness function formula

Wherein p is_iIndicates the number of dup covered by the ith test case, q_iIndicating the number of dup' covered by the ith test case and related to integer overflow errors, n indicating the number of all dups in the program, and m indicating all integer overflow errors in the programThe number of false dup's, which is a weight parameter, 0<<1。

7. The method for generating testcases in the ontology language according to claim 1, wherein the step (6) of setting the algorithm execution limit includes two steps: (1) the iteration times of the genetic algorithm are finished, if the highest algebraic limit is reached, the fitness value still does not reach 1; (2) and (4) within the upper limit of the genetic algebra, if the fitness value reaches 1, storing the result generated by the current test case, then carrying out the next generation experiment, if the fitness value of the experiment result is smaller than that of the parent generation, ending, and taking the previous generation result.

8. The solidity language-oriented test case generation method according to claim 1, wherein the step (6) includes the following steps:

(61) calculating individual fitness values in the population: for each generated individual, namely each test case, putting corresponding test data into a program for execution, calculating the number of covered dup, which is recorded as p, the number of covered dup', which is recorded as q, in a way of pre-instrumentation of a source program, and when the value of q is counted, the precondition is that under the current individual execution state, the operation of a variable meets an overflow condition, and then the variable is recorded as one-time effective coverage of an integer overflow error, and an individual fitness value is calculated according to a fitness function;

(62) and (3) performing iterative execution of a genetic algorithm, and selecting an optimal result in the algorithm: and (4) performing iterative execution of the genetic algorithm according to a roulette selection method, a uniform crossover operator and a variation in the genetic algorithm, wherein the fitness value calculation is performed in the step (61) every time the genetic algorithm performs the fitness value calculation until the algorithm execution limit is reached, and finally obtaining an algorithm result.

Images