JP6245006B2 - Test case generation apparatus, method, and program - Google Patents

Description

  The disclosed technology relates to a test case generation apparatus, method, and program.

  In software development, a method for exhaustively extracting the path from the start of the program to be inspected to the end of the program being inspected (inspected program) and verifying the operation of the inspected program is known. ing.

  As a path extraction method, for example, a path coverage that exhaustively extracts all paths included in the program to be inspected, and a path set that executes one or more branch destinations of all conditional branch instructions included in the program to be inspected are used. There is branch coverage etc. to extract.

  Then, the program to be inspected is comprehensively executed based on the path thus extracted, and the operation of the program to be inspected is verified by determining whether or not the program to be inspected performs the intended operation. .

Japanese Patent Laid-Open No. 11-232137 JP-A-9-128266

  However, in path extraction based on path coverage, when the loop end condition included in the program to be inspected is not a specific numerical value but is represented by including a symbol value such as α, the loop end condition becomes an indefinite value. Therefore, there may be an infinite number of paths that continue the loop, and so-called path explosion may occur where the number of paths extracted becomes enormous.

  As a path explosion prevention measure, for example, a method of reducing the number of paths to be extracted from the number of paths extracted from the program to be inspected by path coverage by using a path extraction method as branch coverage is adopted.

  However, for example, in known branch coverage such as DART (Directed Auto-mated Random Testing), more paths may be extracted than the minimum number of paths that realize branch coverage.

  Therefore, the disclosed technique aims to extract from the program to be inspected a path set that can improve the branch coverage with a smaller number of paths.

  In the disclosed technique, the management unit manages the number of branch executions to the branch destination of the conditional branch included in the program to be inspected. The detection unit compares the branch information corresponding to the route candidate obtained from the number of branch executions with the branch information corresponding to the already extracted route of the program to be inspected, and the route candidate is included in the already existing route. Detect whether the route. The selection unit determines a branch destination based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and selects a path from the start to the end of the program to be inspected. The generation unit generates branch information corresponding to the selected route as branch information corresponding to the existing route. When the detection unit detects that the route candidate is not an overlapping route, the control unit executes processing by each of the selection unit and the generation unit, and when the detection unit detects that the route candidate is an overlapping route, the control unit selects The selection unit and the generation unit are controlled so as not to execute processing by each of the unit and the generation unit.

    As one aspect, the disclosed technique has an effect of extracting a path set that can improve the branch coverage with a smaller number of paths from the program to be inspected.

FIG. 1 is a diagram showing an example of a program to be inspected. FIG. 2 is a diagram showing an example of a flowchart relating to the program to be inspected. FIG. 3 is a diagram showing an example of a path extracted from the program to be inspected. FIG. 4 is a diagram showing an example of a program to be inspected that includes repetitive processing. FIG. 5 is a diagram showing an example of a program to be inspected including an external process call. FIG. 6 is a diagram showing an example of a program to be inspected used for explaining the path explosion. FIG. 7 is a functional block diagram of the test case generation device according to the first embodiment. FIG. 8 is a diagram showing an example of a path tree used for explaining the depth-first search. FIG. 9 is a diagram showing an example of a program to be inspected according to the first embodiment. FIG. 10 is a diagram showing an example of a flowchart of the program to be inspected according to the first embodiment. FIG. 11 is a diagram for explaining management of the number of branch executions. FIG. 12 is a diagram showing an example of a program to be inspected including a multi-branch instruction. FIG. 13 is a diagram for explaining a path selection rule. FIG. 14 is a diagram for explaining a method of generating a duplicate path detection rule. FIG. 15 is a diagram for explaining detection of duplicate paths. FIG. 16 is a diagram for explaining detection of duplicate paths. FIG. 17 is a block diagram of a computer that functions as a test case generation apparatus. FIG. 18 is a flowchart showing the flow of test case generation processing. FIG. 19 is a flowchart showing the flow of duplicate path detection processing. FIG. 20 is a flowchart showing the flow of branch execution frequency management processing according to the first embodiment. FIG. 21 is a flowchart showing the flow of branch selection processing. FIG. 22 is a functional block diagram of the test case generation device according to the second embodiment. FIG. 23 is a diagram showing an example of a program to be inspected that includes a conditional branch instruction in external processing. FIG. 24 is a flowchart showing the flow of branch execution frequency management processing according to the second embodiment.

  Hereinafter, an example of an embodiment of the disclosed technology will be described in detail with reference to the drawings.

  (First embodiment)

  In software development, there is a method of verifying the operation of a program to be inspected using symbolic execution technology.

  Symbolic execution technology means that instead of substituting a specific numerical value for a variable included in the program under test, the program under test is executed in a pseudo manner by substituting a symbol value representing the numerical value, and the program under test is executed. A technique for evaluating the results.

  First, the symbolic execution of the program to be inspected will be briefly described.

  FIG. 1 is a diagram showing an inspected program described in the COBOL language as an example. In the following, when the program to be inspected is illustrated, the program to be inspected written in the COBOL language is shown, but it goes without saying that the program to be inspected may be described in a program language other than the COBOL language. Yes.

  The IF statement on the 13th line in FIG. 1 branches the process to the 15th line when the gender variable is “male”, and branches the process to the 17th line when the gender is not “male”. It is an example of a conditional branch instruction.

  Further, in the program to be inspected shown in FIG. 1, the IF statement is also described on the 19th line. In the IF statement on the 19th line, the process branches to the 21st line when the gender is “female”. If the gender is not “female”, the process branches to the 23rd line.

  FIG. 2 is a flowchart showing the program to be inspected in FIG.

  When symbolic execution is performed on such a program to be inspected, the value of gender as a variable is given from outside the program to be inspected, so it is undefined during symbolic execution, and the value of gender as a variable is Specified as a symbol value. In this way, a variable that is replaced with a symbol value during symbolic execution is called an external variable.

  As a result of the symbolic execution, three paths including the executable path 1, path 2, and path 3 as shown in FIG. 3 and path conditions for each path are extracted. Here, the path condition is a condition in which all conditions including a symbol value are connected by a product (AND condition: hereinafter, indicated by symbol ∧) among conditional branches that are passed until the path is completed. In other words, the path condition can be said to be a logical restriction that must be satisfied when passing through a conditional branch included in the path. Also, “pass is executable” means that the path condition can be satisfied.

  Path 1 is a path that passes through Step S10, Step S12, Step S16, and Step S20 of FIG. 2, and Path 2 is a path that passes through Step S10, Step S14, Step S16, and Step S18 of FIG. is there. Further, the path 3 is a path that passes through Step S10, Step S14, Step S16, and Step S20 of FIG.

  Each of the path conditions of path 1, path 2, and path 3 is logically satisfied and can be satisfied. In the pass condition, ‘! 'Represents a NOT condition. That is, ‘! = 'Indicates that the right side and the left side are not equal.

  On the other hand, the path 4 is a path that passes through step S10, step S12, step S16, and step S18 of FIG. 2. At this time, the path condition of the path 4 is (sex = male) ∧ (gender = female). It becomes. Therefore, the path condition of path 4 is not logically satisfied. That is, since the path condition of the path 4 cannot be satisfied, the path 4 is not determined to be executable and is not extracted as a path.

  In addition, for example, a constraint solver such as a SAT (satisfiability) or SMT (satisfiability modulus theory) solver is used to determine the satisfiability of the path condition.

  Each of the executable paths extracted by symbolic execution in this way is generated as a test case, and the value of the external variable that satisfies the path condition for each path is the test data of the program to be inspected corresponding to each test case. Become.

  As a path search algorithm in symbolic execution, a depth-first search algorithm, which is one of path extraction methods for realizing path coverage, may be used.

  The depth-first search algorithm searches for one path from the start point to the end point of the program to be inspected, then goes back to the point where the path branch point is located on the searched path, and is still selected at the branch point. It is an algorithm that repeats the path of a non-branch destination sequentially.

  In the symbolic execution, the satisfiability of the path is determined using the previously described constraint solver for the path condition corresponding to the path searched by the depth-first search algorithm, and an executable path is extracted.

  However, when the depth-first search algorithm is used to search for a path during symbolic execution, a so-called path explosion occurs in which the number of extracted paths becomes so large that it cannot be processed in reality. Sometimes.

  The following two cases can be considered as causes of the path explosion.

  The first cause of the path explosion is when the number of paths that can be executed by the program to be inspected is infinite. For example, this case corresponds to the case where the program to be inspected includes repetition processing and the repetition end condition includes a symbol value.

  For example, the program to be inspected shown in FIG. 4 includes a repetition process from the 10th line to the 14th line, and every time the repetition process is executed, the value of the counter variable is incremented by one. When becomes larger than the threshold variable, the iterative process is terminated.

  Here, since the threshold variable is an external variable, it is executed as a symbol value during symbolic execution. That is, since the value of the threshold variable becomes indefinite during symbolic execution, there are always paths that continue to be repeated, and the number of paths is infinite.

  In addition, the program to be inspected shown in FIG. 5 includes a PERFORM statement for branching the execution destination to the external process on the 15th line, and the execution destination according to the return value of the CALL statement included in the external process on the 16th line. Contains a conditional branch to be determined. External processing may also be referred to as a subroutine.

  In the conditional branch on the 16th line, when the return value is 0, the external process is recursively called. Therefore, if the return value of the CALL statement is a symbol value, the return value of the CALL statement becomes indefinite, so the recursive call process There are always paths that continue, and the number of paths is infinite.

  The second cause of the path explosion is that when extracting a path in symbolic execution, the analysis time required for path extraction exceeds the actual time, or the amount of memory required for path extraction is the amount of memory installed in the computer. It is a case of exceeding. For example, this case corresponds to a case where conditional branch instructions are frequently used continuously in the program to be inspected.

  Here, the analysis time required for path extraction exceeds the realistic time, for example, the time required to finish extracting the path included in the program to be inspected is the operation verification process period of the program to be inspected in advance. When it does not fit within.

  For example, the program to be inspected shown in FIG. 6 includes 20 independent IF statements. When N such independent IF sentences are consecutive, the number of paths is 2 to the Nth power, and in the example of FIG. 6, 2 to the 20th power, that is, 1048576 paths are extracted from the program to be inspected.

  As an example, when the amount of memory installed in the computer is 1 GB (gigabyte), the path of the program to be inspected including 15 independent IF statements can be extracted. However, if an attempt is made to extract a path of a program to be inspected that includes 16 independent IF statements, a memory shortage occurs and the path cannot be extracted from the program to be inspected.

  In this case, even if the amount of memory mounted on the computer is increased to 6 GB, which is six times, only the path of the program to be inspected including 18 independent IF statements can be extracted. As can be seen from this example, it is understood that a path explosion easily occurs when independent IF sentences are continued.

  Therefore, as a path extraction method for preventing path explosion in symbolic execution, there are cases where branch coverage, instruction coverage, etc., in which the number of extracted paths is suppressed rather than path coverage represented by the depth-first search algorithm, may be used. Note that instruction coverage is a path extraction method for extracting a set of paths for executing all instructions included in a program to be inspected.

  As a conventional path extraction method for preventing path explosion, there are, for example, a branch random search method, a method using a control flow graph (CFG), DART, and the like.

  The branch random search method is a method of extracting a path from a program to be inspected by randomly selecting a branch destination if a conditional branch reached by symbolic execution can be branched. In the method using CFG, first, a so-called CFG is generated in which all paths of a program to be inspected that may pass through symbolic execution are represented by a graph. The conditional branch is weighted so that the symbolic execution line reaches the non-passed command statement on the generated CFG, and the branch destination of the conditional branch is determined based on the branch condition weight.

  DART is an improved version of the branch random search method. First, a specific value is randomly set in an external variable, the program to be inspected is executed, and path conditions on the path are collected. Next, from the collected path conditions, a value that passes a path different from the path that has already passed is generated, and paths are sequentially extracted from the program to be inspected.

  Hereinafter, an example of extracting a path using DART from the program to be inspected shown in FIG. 6 will be described.

Procedure A: The value of each external variable of item 1 to item 20 is temporarily set as “1”.
Procedure B: Collect path conditions based on the values of the external variables of items 1 to 20. For example, when the external variable value set in the procedure A is used, path conditions of “(item 1 = 1) ∧ (item 2 = 1) ∧... (Item 20 = 1)” are collected.
Procedure C: Next, a path condition in which a part of the path conditions collected in Procedure B is negated, for example, “! (Item 1 = 1) ∧ (item 2 = 1) ∧... ∧ (item 20 = 1)” To derive a value that satisfies the path condition. In the case of this example, for example, values of item 1 = “2”, item 2 to item 20 = “1” are obtained.

  Thereafter, the procedure B and procedure C are repeated until an end condition related to path extraction, for example, branch coverage is satisfied, and a path is extracted from the program to be inspected.

  However, the branch random search method, the method using CFG, and DART have the following problems.

  In the branch random search method, since the branch destination of the conditional branch is selected at random, the branch destination that has not passed cannot be selected intentionally. Therefore, when trying to obtain a test case that realizes branch coverage, there are problems that the number of repetitions of the path search increases and the number of paths extracted from the program to be inspected also depends on chance.

  In the method using the CFG, it is necessary to statically analyze the program to be inspected, graph all routes included in the program to be inspected in advance, and further weight the conditional branches. Therefore, when the method using CFG is applied to a large program to be inspected that includes several tens of conditional branches in one path, the amount of calculation required for static analysis of the program to be inspected increases, It may be difficult to apply due to constraints such as time and memory amount.

  In addition, in DART, when generating a path set that realizes branch coverage, there is a problem that a path set including more paths is generated than the minimum path set that realizes branch coverage. .

  For example, as described above, when a path is extracted from the program to be inspected shown in FIG. 6 by DART, first, one path corresponding to the path condition collected in the procedure A is extracted. Then, for the path conditions collected in procedure A, 20 paths are extracted while sequentially negating each branch condition from (item 1 = 1) to (item 20 = 1). In total, a total of 21 paths are extracted.

  However, in the case of the program to be inspected shown in FIG. 6, for example, branch coverage can be realized by two paths: a path that branches all to the THEN side and a path that branches all to the ELSE side in each conditional branch. The minimum number of paths for realizing branch coverage is 2.

  On the other hand, the disclosed technique extracts from the program to be inspected a path set that can improve the branch coverage with a smaller number of paths as compared with the conventional path extraction method used for branch coverage.

  FIG. 7 shows a test case generation apparatus 10 according to the present embodiment. The test case generation device 10 includes an input unit 12, a symbolic execution unit 14, a control unit 16, a depth priority search unit 18, a management unit 20, a selection unit 22, a generation unit 24, a detection unit 26, and an output unit 28.

  The test case generation apparatus 10 is an apparatus for generating a test case 32 for executing an inspected program 30 by a symbolic execution technique and verifying the operation of the inspected program 30.

  The input unit 12 receives the program to be inspected 30 and takes the program to be inspected 30 into the test case generation apparatus 10.

  The symbolic execution unit 14 sets a symbol value instead of setting a specific value for the external variable included in the program 30 to be inspected received via the input unit 12. Then, a path included in the inspected program 30 searched by the control unit 16 is simulated while the external variable is set as a symbol value, and a path is extracted from the inspected program 30. Then, a path condition is extracted for each executed path, and a plurality of test cases are generated by using one path and a combination of path conditions corresponding to the path as one test case. In addition, a value of an external variable that satisfies the pass condition of each test case is generated and used as test data of the inspected program 30 corresponding to the test case.

  The control unit 16 controls the function units of the depth priority search unit 18, the management unit 20, the selection unit 22, the generation unit 24, and the detection unit 26, which will be described later, in the symbolic execution, so that the program to be inspected 30. Perform a search for included paths. Then, the control unit 16 passes the searched path to the symbolic execution unit 14.

  The depth priority search unit 18 comprehensively searches for paths from the program to be inspected 30 based on a depth priority search algorithm.

  FIG. 8 is a diagram for explaining the path search algorithm of the program to be inspected shown in FIG.

  When an arbitrary path 1 is searched, the path 2 is searched by selecting an unselected branch side from the end point of the path 1 to the branch point (item 20 = 1). Next, the path 3 is searched by going back to the branch point having the unselected branch destination from the end point of the path 2, to the branch point in this case (item 19 = 1), and selecting the unselected branch side. Thereafter, the same processing is repeated to exhaustively search for paths included in the program 30 to be inspected.

  The depth-first search unit 18 is a functional unit that is called by the control unit 16 when exhaustively searching for paths from the program to be inspected 30, and the test case generation device 10 executes path extraction by branch coverage. Is not an essential functional part.

  The management unit 20 manages the number of branch executions to the branch destination for each conditional branch included in the program 30 to be inspected based on the execution order of the paths searched by the control unit 16. Below, the function of the management part 20 is demonstrated in detail.

  FIG. 9 is a diagram showing an example of the program to be inspected 30 according to the present embodiment. In the program to be inspected 30 shown in FIG. 9, IF statements that are conditional branch instructions exist in a total of three locations on the 13th line, the 19th line, and the 25th line. Further, “EXIT PROGRAM” indicating the end of the program to be inspected 30 exists on the 16th, 20th, 26th, and 36th lines.

  FIG. 10 is a flowchart of the program to be inspected 30 shown in FIG. Each process of step S30, step S34, and step S38 corresponds to the conditional branch of the 13th line, the 19th line, and the 25th line of the inspected program 30 in FIG. In addition, each process of step S32, step S36, and step S40 corresponds to the process of the 14th line, the 22nd line, and the 28th line of the program 30 to be inspected in FIG.

  FIG. 11 is a diagram showing the management contents of the program 30 to be inspected shown in FIG. First, the management unit 20 acquires an IF statement that is a conditional branch instruction from the program to be inspected 30. Then, the management unit 20 sets the number of branch executions of each IF statement in the state before the path search of the program 30 to be inspected for the first time by the control unit 16, that is, in the initial state, for example, “direct = (0, 0)”. ”. Here, “directly” means that the corresponding IF statement is not executed as an IF statement of an external process called by a PERFORM statement or the like. Further, (0, 0) represents the number of branch executions on the THEN side and the number of branch executions on the ELSE side in the IF statement in the order of arrangement.

  For example, assume that the control unit 16 searches for a path represented by step S30 → step S32 → step S34 → end shown in FIG. In this case, since the branch on the THEN side (THEN branch) is selected in the IF statement on the 13th line, the number of branch executions on the THEN side of the IF statement (13th line) is increased by 1, and “direct = (1, 0) " Also, since the THEN branch is selected in the IF statement on the 19th line, the number of branch executions of the IF statement (19th line) is “direct = (1, 0)”.

  Next, suppose that the control unit 16 searches for a path represented by, for example, step S30 → end. In this case, since the branch on the ELSE side (ELSE branch) is selected in the IF statement on the 13th line, the number of branch executions on the ELSE side of the IF statement (13th line) is increased by 1 and “direct = (1, 1)”. "

  Next, assume that the control unit 16 searches for a path represented by, for example, step S30 → step S32 → step S34 → step S36 → step S38 → end. In this case, the number of branch executions of the IF statement (line 13) is “direct = (2, 1)” and the number of branch executions of the IF statement (line 19) is “direct = (1, 1) ”, and the IF statement (25th line) branch execution count is“ direct = (1, 0) ”.

  Thereafter, every time a path is searched for by the control unit 16, the number of branch executions of the IF statement executed by the searched path is updated according to the method described above.

  In addition to the IF statement, the conditional branch instruction includes a multi-branch instruction such as an EVALUATE statement that selects a process that meets a condition from a plurality of different processes.

  FIG. 12 is a diagram showing an example of the inspected program 30 including the EVALUATE sentence.

  The inspected program 30 shown in FIG. 12 includes two EVALUATE statements on the 12th and 23rd lines.

  In the initial state, the management unit 20 initializes the branch execution count of the EVALUATE statement on the 12th line, for example, “direct = (0, 0, 0, 0)”. Here, (0, 0, 0, 0) means the number of branch executions when the variable 1 is “A”, the number of branch executions when the variable 1 is “B”, and the variable 1 is “C”. Represents the number of branch executions in the case where the variable 1 does not correspond to any of “A”, “B”, and “C”.

  In addition, the management unit 20 initializes the number of branch executions of the EVALUATE statement on the 23rd line in the initialization state, for example, “direct = (0, 0, 0)”.

  Then, the management unit 20 manages the number of branch executions of the EVALUATE statement, similarly to the management of the number of branch executions in the IF statement. For example, when the control unit 16 searches for paths for executing the DISPLAY statements on the 14th and 25th lines, the number of branch executions of the EVALUATE statement (12th line) is “direct = (1, 0, 0, 0 ) ”. The number of branch executions of the EVALUATE statement (the 23rd line) is “direct = (1, 0, 0)”.

  The selection unit 22 is a functional unit that is called from the control unit 16 when the control unit 16 searches for a path from the program to be inspected 30, and branches according to a predetermined path selection rule every time the path reaches a conditional branch. Select the destination. Here, the path selection rule is a rule for selecting a branch destination in a conditional branch.

  As an example of the path selection rule, for example, when the conditional branch instruction on the path can branch, the selection unit 22 determines the branch execution count based on the branch execution count for each conditional branch managed by the management unit 20. Select the smaller branch. If the number of branch executions of the conditional branch is the same, the branch destination is selected according to a predetermined selection rule.

  Here, the predetermined selection rule refers to a rule such as selecting the first branch in a conditional branch instruction. Specifically, as an example, when the number of IF statement branch executions is the same, the THEN branch is selected. Note that the predetermined selection rule is not limited to this, and for example, an ELSE branch may be selected.

  Further, the conditional branch instruction being able to branch means a state where both branch conditions of the conditional branch instruction can be satisfied.

  For example, the IF statement on the 13th line of the program to be inspected 30 shown in FIG. 9 is whether or not (item 1 = 1) is a branching condition. In this case, the THEN branch is selected when the branch condition: (item 1 = 1) is TRUE. On the other hand, the ELSE branch is selected when the branch condition: (item 1 = 1) is FALSE. It can be interpreted that (item 1 = 1) is selected when TRUE.

  Since the variable: item 1 included in the branch condition is an external variable, when the program under test 30 shown in FIG. 9 is symbolically executed, the variable: item 1 is replaced with a symbol value. Therefore, the true / false value of the branch condition (item 1 = 1) cannot be determined.

  Therefore, the selection unit 22 determines the branch condition for THEN branch: (item 1 = 1) and the branch condition for ELSE branch:! Judge the possibility of satisfying (Item 1 = 1). In this case, since both the branch condition of the THEN branch and the branch condition of the ELSE branch can be satisfied, the selection unit 22 determines that the IF statement on the thirteenth line of the program under test 30 shown in FIG. , The branch destination is selected from the two branches, the THEN branch and the ELSE branch.

  FIG. 13 is a diagram showing an example of a path searched by the inspected program 30 shown in FIG. 9 in the selection unit 22 only according to the path selection rule already described.

  As shown in FIG. 11, before the first path search, the number of branch executions for each conditional branch managed by the management unit 20 is in an initial state.

  Therefore, in the first path search, the IF statement (line 13) can be branched and the branch execution count is (0, 0), so the THEN branch is selected. Since the IF statement (line 19) can also be branched and the number of branch executions is (0, 0), the THEN branch is selected, and step S30 → step S32 → step S34 → end in FIG. Is selected.

  Next, in the second path search, the branch execution count of the IF statement (line 13) has been updated to (1, 0) by the management unit 20, so that an ELSE branch with a smaller branch execution count is selected. A path 2 represented by step S30 → end in FIG. 10 is selected.

  Next, in the third path search, the THEN branch is selected because the number of branch executions of the IF statement (line 13) is updated to (1, 1) by the management unit 20. Since the branch execution count of the IF statement (line 19) is also updated to (1, 0) by the management unit 20, an ELSE branch having a smaller branch execution count is selected. Since the number of branch executions of the IF statement (line 25) remains in the initial state (0, 0), the THEN branch is selected, and step S30 → step S32 → step S34 → step S36 → step in FIG. The path 3 represented by S38 → end is selected.

  Thereafter, until the branch coverage is realized, the selection unit 22 repeats the same path selection rule, so that seven paths from the path 1 to the path 7 in FIG. 13 are selected.

  The generation unit 24 detects path duplication to indicate that the path of the program 30 to be inspected selected by the selection unit 22 is already selected by the selection unit 22 (existing path). Rule (duplicate path detection rule) is generated.

  FIG. 14 is a diagram showing an example of a duplicate path detection rule generation method in the generation unit 24, taking the program to be inspected 30 shown in FIG. 9 as an example.

  The generation unit 24 generates a duplicate path detection rule based on the priority branch number generated by the detection unit 26 described later and the path selected by the selection unit 22 according to the path selection rule. Here, the priority branch number is a number representing a branch destination for each conditional branch to be selected next when the selection unit 22 complies with the path selection rule.

  As shown in FIG. 14, in the initial state, the number of branch executions of all conditional branches managed by the management unit 20 is (0, 0). Therefore, in each conditional branch, the THEN branch is based on the path selection rule. Will be selected. Therefore, for example, when the THEN branch is represented by “0” and the ELSE branch is represented by “1”, the detection unit 26 performs the IF sentence (13th line), IF sentence (19th line), and IF sentence (25th line). A priority branch number in which the branch destination of each conditional branch is set to “0” is generated.

  On the other hand, when symbolic execution is performed by the symbolic execution unit 14 along the path selected by the selection unit 22 and a path is extracted from the program 30 to be inspected, branch execution for each conditional branch managed by the management unit 20 The number of times is updated as the extracted path is executed.

  When the branch coverage of the program 30 to be inspected is improved by the extracted path, the generation unit 24 generates a priority branch number corresponding to the conditional branch executed by the extracted path as a duplicate path detection rule.

  For example, when the path 1 shown in FIG. 13 is extracted by the first symbolic execution in FIG. 14, the generation unit 24 selects “priority branch number {(IF sentence (13th line) = 0) ∧ (IF sentence If (19th line) = 0)}, the rule 1 “overlapping with the path 1” is generated.

  In FIG. 14, to simplify the description, for example, which priority branch number among the priority branch numbers corresponding to each conditional branch included in the program to be inspected 30 is applied to the duplicate path detection rule. The identifier “*” is assigned to the determination column corresponding to the priority branch number.

  After the first symbolic execution, the detection unit 26 generates a priority branch number based on the number of branch executions for each conditional branch managed by the management unit 20. After the first symbolic execution, the number of branch executions for each IF statement is {(1, 0), (1, 0), (0, 0)} as shown in FIG. Here, the first parenthesis is the number of branch executions of the IF statement (line 13), the second parenthesis is the number of branch executions of the IF statement (line 19), and the third parenthesis is the IF statement (line 25). This represents the number of branch executions.

  Therefore, based on the path selection rule, the priority branch number generated after the first symbolic execution is (1, 1, 0). Here, the first number is the priority branch number of the IF statement (line 13), the second number is the priority branch number of the IF statement (line 19), and the third number is the IF statement (line 25). Represents the priority branch number.

  When the path 2 shown in FIG. 13 is extracted by the second symbolic execution, the generation unit 24 says “If the priority branch number is (IF statement (13th line) = 1), it overlaps with path 2”. Rule 2 is generated.

  After the second symbolic execution, the number of branch executions for each conditional branch managed by the management unit 20 is {(1, 1), (1, 0), (0, 0)} as shown in FIG. Become. Therefore, the priority branch number generated after the second symbolic execution based on the path selection rule is (0, 1, 0). Then, when the path 3 shown in FIG. 13 is extracted by the third symbolic execution, the generation unit 24 “the priority branch number is {(IF sentence (13th line) = 0) ∧ (IF sentence (19th line)). = 1) ∧ (IF statement (25th line) = 0)}, rule 3 is generated, which overlaps with path 3.

  Thereafter, according to the same processing, the generation unit 24 generates duplicate path detection rules until the extraction of paths by symbolic execution is completed. The priority branch number is an example of branch information.

  As already described, when the selection unit 22 selects a path from the program to be inspected 30 shown in FIG. 9 according to only the path selection rule, for example, seven paths that realize branch coverage as shown in FIG. 13 are selected. May be.

  However, in this case, the path 4 and the path 6 are paths that overlap with the path 2, and the path 5 is a path that overlaps with the path 1. Therefore, a new test case is not generated from the symbolic execution based on the path 4, the path 6, and the path 5, and the generation time of the test case is not only wasted, but also contributes to the quality improvement of the inspected program 30. Duplicate test cases will be generated.

  Therefore, based on the number of branch executions for each conditional branch managed by the management unit 20, the detection unit 26 generates a priority branch number according to a path selection rule before path search, and acquires a path candidate represented by the priority branch number. To do. Then, the detection unit 26 compares the priority branch number corresponding to the path candidate with the duplicate path detection rule generated by the generation unit 24 before extraction of the path by the selection unit 22, and extracts the next symbolic execution. It is detected whether or not the scheduled path matches the already-existing path.

  15 and 16 are diagrams showing the processing of the detection unit 26 for the program to be inspected 30 shown in FIG.

  The detection unit 26 generates a priority branch number according to the path selection rule based on the number of branch executions for each conditional branch in the initial state. The priority branch number generated at this time is (0, 0, 0). Then, the detection unit 26 compares the generated priority branch number with the duplicate path detection rule generated by the generation unit 24, and is represented by the generated priority branch number in the duplicate path detection rule. It is determined whether there is a rule that overlaps with the path candidate.

  Then, when there is a rule that overlaps with the path candidate represented by the generated priority branch number, the detection unit 26 prevents the path extraction process by the symbolic execution unit 14 from being performed. On the other hand, when there is no rule that overlaps with the path candidate represented by the generated priority branch number, the detection unit 26 performs the path extraction process by symbolic execution in the symbolic execution unit 14.

  Specifically, when the test case generation device 10 is in the initial state, there is no duplicate path detection rule yet, so the selection unit 22 selects the path 1 in FIG. 13 and the generation unit 24 selects the duplicate path corresponding to the path 1. Detection rule: Rule 1 is generated.

  After the first overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(1, 0), (1, 0), (0, 0) as shown in FIG. }. Therefore, the priority branch number generated by the detection unit 26 next is (1, 1, 0). In this case, since there is only rule 1 in the duplicate path detection rule, there is no rule that duplicates the path candidate represented by the generated priority branch number. Therefore, the selection unit 22 selects the path 2 in FIG. 13, and the generation unit 24 generates the duplicate path detection rule: rule 2 corresponding to the path 2.

  After the second duplicate path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(1, 1), (1, 0), (0, 0) as shown in FIG. }. Therefore, the priority branch number generated by the detection unit 26 next is (0, 1, 0). In this case, rule 1 and rule 2 exist in the duplicate path detection rule, but no rule overlaps with the path candidate represented by the generated priority branch number. Therefore, the selection unit 22 selects the path 3 in FIG. 13, and the generation unit 24 generates the duplicate path detection rule: rule 3 corresponding to the path 3.

  After the third overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(2, 1), (1, 1), (1, 0) as shown in FIG. }. Accordingly, the priority branch number generated next by the detection unit 26 is (1, 0, 1). In this case, rule 1, rule 2, and rule 3 exist in the duplicate path detection rule, and the path candidate represented by the generated priority branch number matches rule 2. Therefore, the path extraction process by symbolic execution according to the path candidate that matches the duplicate path detection rule is omitted. Specifically, the path selection process in the selection unit 22 and the generation process of the duplicate path detection rule in the generation unit 24 are omitted. However, even when the path candidate represented by the generated priority branch number matches the duplicate path detection rule, the management unit 20 performs the number of branch executions for each conditional branch as the path candidate is generated. Update.

  After the fourth overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(2, 2), (1, 1), (1, 0) as shown in FIG. }. Accordingly, the priority branch number generated next by the detection unit 26 is (0, 0, 1). In this case, rule 1, rule 2, and rule 3 exist in the duplicate path detection rule, and the path candidate represented by the generated priority branch number matches rule 1. Therefore, the path extraction process by symbolic execution according to the path candidate that matches the duplicate path detection rule is omitted.

  After the fifth overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(3, 2), (2, 1), (1, 0) as shown in FIG. }. Accordingly, the priority branch number generated next by the detection unit 26 is (1, 1, 1). In this case, rule 1, rule 2, and rule 3 exist in the duplicate path detection rule, and the path candidate represented by the generated priority branch number matches rule 2. Therefore, the path extraction process by symbolic execution according to the path candidate that matches the duplicate path detection rule is omitted.

  After the sixth overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(3, 3), (2, 1), (1, 0) as shown in FIG. }. Therefore, the priority branch number generated by the detection unit 26 next is (0, 1, 1). In this case, the duplicate path detection rule has no rule that overlaps with the path candidate represented by the generated priority branch number. Accordingly, the selection unit 22 selects the path 7 in FIG. 13, and the generation unit 24 generates the duplicate path detection rule: rule 4 corresponding to the path 7. Note that rule 4 indicates that if the priority branch number is {(IF statement (13th line) = 0) ∧ (IF statement (19th row) = 1) ∧ (IF statement (25th row) = 1)}. , Overlaps with path 7 ”.

  After the seventh overlapping path detection process, the branch execution count for each conditional branch managed by the management unit 20 is {(4, 3), (2, 2), (1, 1) as shown in FIG. }. In this case, since the number of branch executions for each conditional branch included in the program to be inspected is 1 or more, branch coverage is realized by the path 1, the path 2, the path 3, and the path 7. Therefore, the detection unit 26 ends the duplicate path detection process.

  The test case generation device 10 described above can be realized by, for example, the computer 40 shown in FIG. The computer 40 includes a CPU 42, a memory 44, and a nonvolatile storage unit 46, which are connected to each other via a bus 48.

  The storage unit 46 can be realized by an HDD (Hard Disk Drive) or a flash memory. The storage unit 46 as a storage medium stores a test case generation program 50 for causing the computer 40 to function as the test case generation apparatus 10 for the program 30 to be inspected. The CPU 42 reads the test case generation program 50 from the storage unit 46 and expands it in the memory 44, and sequentially executes various processes included in the test case generation program 50.

  The test case generation program 50 includes a symbolic execution process 52, a control process 54, a management process 56, a selection process 58, a generation process 60, a detection process 62, a depth-first search process 64, an input process 66, and an output process 68.

  The CPU 42 operates as the symbolic execution unit 14 illustrated in FIG. 7 by executing the symbolic execution process 52. Further, the CPU 42 operates as the control unit 16 illustrated in FIG. 7 by executing the control process 54. The CPU 42 operates as the management unit 20 illustrated in FIG. 7 by executing the management process 56. The CPU 42 operates as the selection unit 22 illustrated in FIG. 7 by executing the selection process 58. The CPU 42 operates as the generation unit 24 illustrated in FIG. 7 by executing the generation process 60. Further, the CPU 42 operates as the detection unit 26 illustrated in FIG. 7 by executing the detection process 62. Further, the CPU 42 operates as the depth priority search unit 18 illustrated in FIG. 7 by executing the depth priority search process 64. The CPU 42 operates as the input unit 12 illustrated in FIG. 7 by executing the input process 66. The CPU 42 operates as the output unit 28 illustrated in FIG. 7 by executing the output process 68.

  As described above, the computer 40 that has executed the test case generation program 50 operates as the test case generation apparatus 10. Note that the test case generation program 50 is an example of a test case generation program in the disclosed technology.

  Note that the test case generation apparatus 10 can be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC (Application Specific Integrated Circuit) or the like.

  Next, the operation of the test case generation device 10 according to the present embodiment will be described. When the inspected program 30 is input to the input unit 12, the test case generation apparatus 10 according to the present embodiment executes a test case generation process shown in FIG. In the following description, the inspected program 30 shown in FIG. 9 will be described as an example of the inspected program 30 input to the input unit 12. Further, when the test case generation program 50 is read from the storage unit 46 and expanded in the memory 44, the number of branch executions for each conditional branch of the program under test 30 stored in a predetermined area of the memory 44 is {(0 , 0), (0, 0), (0, 0)}. Also, the duplicate path detection rule generated by the generation unit 24 is initialized so as not to include any rule.

  In step S <b> 100, the input unit 12 acquires the program to be inspected 30 input to the input unit 12 and stores it in the memory 44, for example. Further, the input unit 12 notifies the symbolic execution unit 14 that the program to be inspected 30 has been input.

  In step S <b> 102, the symbolic execution unit 14 determines whether a path search end condition for the program to be inspected 30 is satisfied.

  Here, the path search end condition means that any one of the following three conditions is satisfied.

(Termination condition 1) The branch coverage is achieved by the existing path.
(Termination condition 2) The branch coverage does not change over the number of times of convergence.
(End condition 3) The number of path searches reaches the number of path searches.

  (End condition 1) is, for example, when the number of branch executions for each conditional branch included in the program under test 30 stored in the memory 44 by the management unit 20 is 1 or more, the path search is ended. It is a condition to do.

  The (end condition 2) is, for example, when the ratio of the number of branches actually searched for the number of branches included in the program to be inspected 30 does not continuously change over a predetermined number of convergence times. This is a condition for ending the search.

  Specifically, if the number of branch executions for each conditional branch is {(1, 1), (1, 0), (0, 0)}, the number of all branches included in the program 30 to be inspected is 6. Yes, since the number of branches actually searched for paths is 3, the branch coverage is 50%. Even if the path search is repeated from this state of branch coverage, the condition is determined to be satisfied if the branch coverage remains unchanged at 50% for the number of convergences.

  (End condition 3) is that the number of times the symbolic execution unit 14 notifies the control unit 16 of a path search instruction and causes the control unit 16 to search for a path reaches a predetermined number of path searches. This is a condition for ending the search.

  The convergence count and path search count are stored in advance in the storage unit 46, but may be acquired via the input unit 12 and stored in the storage unit 46, for example.

  If the symbolic execution unit 14 determines that the path search termination condition is satisfied, the symbolic execution is terminated and the process proceeds to step S104. If it is determined that the path search termination condition has not yet been established, the symbolic execution unit 14 notifies the control unit 16 of a path search instruction, and the process proceeds to step S106.

  In step S106, the control unit 16 starts a path search in response to a path search instruction from the symbolic execution unit 14. First, the control unit 16 notifies the detection unit 26 of an execution instruction for the duplicate path detection process, and causes the detection unit 26 to execute the duplicate path detection process.

  FIG. 19 is a flowchart showing the contents of the duplicate path detection process in step S106.

  In step S200, the detection unit 26 refers to the number of branch executions for each conditional branch of the program under test 30 stored in a predetermined area of the memory 44, and generates a priority branch number based on the path selection rule. .

  For example, when the test case generation device 10 is in the initial state, the number of branch executions for each conditional branch of the program under test 30 is {(0, 0), (0, 0), (0, 0)}. The priority branch number generated based on the path selection rule is (0, 0, 0).

  In step S202, the detection unit 26 compares the priority branch number generated in step S200 with the duplicate path detection rule generated by the generation unit 24 by the process in step S124 described later. If the duplicate path detection rule includes a rule that matches at least a part of the priority branch number generated in step S200, the detection unit 26 determines that the path candidate represented by the generated priority branch number is an existing path. Is notified to the control unit 16.

  In step S108, the control unit 16 receives the result of the duplicate path detection process from the detection unit 26, and based on the result of the duplicate path detection process, the path candidate scheduled to be extracted by the current path search is the existing path. It is determined whether or not.

  If the path candidate overlaps with the already-exited path, the process proceeds to step S110. If the path candidate does not overlap with the already-existing path, the process proceeds to step S112.

  In step S110, the control unit 16 requests the management unit 20 to update the number of branch executions for each conditional branch included in the program to be inspected 30. Based on the value of the priority branch number corresponding to the path candidate generated by the detection unit 26, the management unit 20 updates the number of branch executions for each conditional branch stored in a predetermined area of the memory 44, for example. Then, the process proceeds to step S102 and the search for the path included in the program to be inspected 30 is repeated.

  On the other hand, in step S <b> 112, the control unit 16 reads one line of a command sentence from the program to be inspected 30 stored in the memory 44. In step S114, the control unit 16 notifies the selection unit 22 of an execution instruction for the branch selection process together with the instruction sentence read in step S112, and causes the selection unit 22 to execute the branch selection process.

  In step S <b> 114, if the instruction sentence notified from the control unit 16 is a conditional branch instruction, the selection unit 22 determines whether the conditional branch instruction can be branched. Then, when the conditional branch instruction can be branched, the selection unit 22 selects a branch destination according to the already described path selection rule. Details of the branch selection process in step S114 will be described later.

  In step S <b> 116, the control unit 16 requests the management unit 20 to update the number of branch executions for each conditional branch included in the program to be inspected 30.

  FIG. 20 is a flowchart showing the contents of the branch execution frequency management process in step S116, which is performed by the management unit 20.

  In step S400, the management unit 20 determines whether or not the instruction sentence read by the control unit 16 in the process of step S112 is a conditional branch instruction. If the determination is negative, the management unit 20 ends the branch execution number management process. On the other hand, if the determination is affirmative, the process proceeds to step S402.

  In step S402, the management unit 20 acquires the branch destination of the conditional branch instruction selected by the selection unit 22 from the predetermined area of the memory 44 as a result of the branch selection process in step S114. If the conditional branch instruction is an IF statement, for example, 'TRUE' or 'FALSE' is stored in a predetermined area of the memory 44 by the selection unit 22, and if the conditional branch instruction is an EVALUATE statement, the branch destination number is It is remembered. In this case, for example, when the branch destination number is “1”, it means that the first WHEN statement of the EVALUATE statement has been executed, and when the branch destination number is “2”, the second of the EVALUATE statement This means that the WHEN statement has been executed.

  In step S404, the management unit 20 increases the branch execution count of the corresponding conditional branch instruction by one based on the branch destination of the conditional branch instruction acquired in the process of step S402, for example, a predetermined area of the memory 44 To remember.

  As described above, the branch execution frequency management process in step S116 is executed by the processes in steps S400 to S404.

  Next, in step S118, the control unit 16 determines whether or not the instruction sentence read in the process of step S112 is an instruction sentence indicating the end of the program 30 to be inspected, for example, “EXIT PROGRAM”. If the determination is negative, the process proceeds to step S120. In step S120, since the search for one path has not been completed yet, the control unit 16 updates the address on the memory 44 in which the command statement to be read next is stored. And it transfers to step S112 and searches one path | pass from the to-be-inspected program 30 by repeating the process of step S112-step S120.

  In step S120, the control unit 16 sequentially stores, for example, the line numbers of the statements to be read next from the inspected program 30 in the memory 44, and can specify the execution path of the inspected program 30 after the path search is completed. Keep it like that.

  On the other hand, when it becomes affirmation determination in the process of step S118, it transfers to step S122. The fact that the process of step S118 is affirmative means that one path has been searched for from the program to be inspected 30. When the process proceeds to step S122, the control unit 16 associates the number of branch executions for each conditional branch corresponding to the searched path with the number of path searches and saves it in a predetermined area of the memory 44.

  In step S122, the control unit 16 calculates the branch coverage (latest branch coverage) of the program to be inspected 30 in consideration of the path newly searched by the processing in steps S112 to S120. As already described in the process of step S102, the branch coverage of the program under test 30 is calculated by referring to the number of branch executions for each conditional branch stored in the memory 44, for example.

  Then, the control unit 16 compares the latest branch coverage with the branch coverage (existing path branch coverage) of the inspected program 30 calculated based on the existing path stored in the memory 44, for example, and the branch coverage. Judge whether the degree has improved.

  When the branch coverage does not improve, that is, when the latest branch coverage is equal to the existing path branch coverage, the process proceeds to step S102 without performing the processing of step S124 and step S126 described later, and the program to be inspected 30 starts the next. Search for the path. On the other hand, when the branch coverage is improved, that is, when the latest branch coverage is larger than the existing path branch coverage, the process proceeds to step S124.

  In step S124, the control unit 16 notifies the generation unit 24 of an instruction for generating a duplicate path detection rule. In this case, the generation unit 24 uses the difference between the branch execution count for each conditional branch corresponding to the newly searched path and the branch execution count for each branch condition corresponding to the previously searched path, to the newly searched path. The branch destination for each conditional branch included in is specified. Then, the generation unit 24 newly searches based on the branch destination for each conditional branch included in the specified newly searched path and the priority branch number generated by the detection unit 26 in step S200 of FIG. A duplicate path detection rule corresponding to the path is generated.

  Specifically, as shown in FIG. 14, for example, among the priority branch numbers for each conditional branch, the priority branch number of the conditional branch through which the newly searched path has passed is determined in advance in the memory 44 as a duplicate path detection rule. Store in the area.

  The duplicate path detection rule generated in this way is used in the duplicate path detection process in step S106 described above.

  The method for specifying a newly searched path is not limited to this, and any method may be used as long as the searched path can be specified.

  In step S126, the symbolic execution unit 14 performs symbolic execution based on the searched path, and extracts a path condition corresponding to the path searched from the program to be inspected 30 when the searched path is executable. To do. Then, the symbolic execution unit 14 generates information combining the path extracted by the symbolic execution and the path condition corresponding to the path as a test case, and stores the information in a predetermined area of the memory 44, for example.

  After the test case is generated, the process proceeds to step S102, and the process for generating the next test case from the program to be inspected 30 is repeated.

  When the symbolic execution unit 14 determines that the path search end condition is satisfied in the process of step S102, the output unit 28 stores the generated test case in the process of step S104, for example, in the memory 44 or the like. Output all at once.

  Note that the output destination of the test case is not limited to the memory 44, and may be, for example, a terminal device (not shown) connected to the computer 40 via a wired line or a wireless line, or a portable storage device such as a USB (Universal Serial Bus) memory. There may be.

  As described above, the test case generation apparatus 10 according to the present embodiment, even if a new path is searched, if the branch coverage is not improved, the priority branch number corresponding to the new path is set as the duplicate path detection rule. It is not used and no symbolic execution is performed.

  Therefore, a redundant path detection rule is generated from the priority branch numbers corresponding to all the searched paths, and unnecessary test cases that do not lead to improvement of branch coverage can be eliminated in advance compared to the case where symbolic execution is performed. it can. In addition, since unnecessary test cases that do not lead to an improvement in branch coverage are eliminated in advance, the time required for generating test cases can be shortened.

  Next, the contents of the branch selection process in step S114 will be described.

  FIG. 21 is a flowchart showing the contents of the branch selection process in step S114, which is performed by the selection unit 22.

  In step S300, the selection unit 22 determines whether or not the instruction sentence read by the control unit 16 in the process of step S112 in FIG. 18 is a conditional branch instruction. If the determination is negative, the branch selection process ends. On the other hand, if the determination is affirmative, the process proceeds to step S302.

  In step S <b> 302, the selection unit 22 acquires a branch condition from the read conditional branch instruction, and stores it in a predetermined area of the memory 44, for example. Note that the branch condition of the conditional branch instruction included in the path being searched is sequentially stored in a predetermined area of the memory 44 by the process of step S302.

  In step S304, the selection unit 22 refers to the program to be inspected 30 and evaluates whether or not the true / false value of the branch condition acquired in the process of step S302 can be determined. For example, if the branch condition is (item 1 = 1), the true / false value of the branch condition can be determined if the value of item 1 is determined as a specific numerical value in the program under test 30.

  In step S306, the selection unit 22 determines whether or not the true / false value of the branch condition evaluated by the process of step S304 is confirmed. If the determination is affirmative, the process proceeds to step S308.

  In step S308, the truth value of the branch condition acquired in step S302 is confirmed, and the selection unit 22 associates the branch condition acquired in the process of step S302 with the true / false value determined in the branch condition. For example, it is stored in a predetermined area of the memory 44. Then, the branch selection process shown in FIG.

  On the other hand, in the process of step S306, when it is determined that the true / false value of the branch condition evaluated by the process of step S304 cannot be determined, the process proceeds to step S310.

  In step S310, the selection unit 22 evaluates the satisfiability of all branch conditions included in the currently searched path stored in the memory 44 in the process of step S302.

  For example, it is assumed that a branch condition (gender = 'male') exists in the past branch condition included in the currently searched path, and the truth value corresponding to the branch condition is 'TRUE'. . In this case, even if the branch condition that the true / false value cannot be determined (gender = 'female') by the single branch condition is acquired in the process of step S302, the true / false value of the past branch condition is calculated. The false value can be fixed to 'FALSE'.

  In this way, in step S312, the selection unit 22 determines whether or not the branch destination of the branch condition acquired in the process of step S302 can be determined. If the determination is affirmative, the process proceeds to step S314.

  In step S314, the truth value of the branch condition acquired in step S302 is confirmed, and the selection unit 22 associates the branch condition acquired in step S302 with the truth value of the branch condition, for example, the memory 44. Is stored in a predetermined area. Then, the branch selection process shown in FIG.

  On the other hand, if a negative determination is made in the process of step S312, the process proceeds to step S316, and the selection unit 22 selects the branch destination of the branch condition acquired in the process of step S302 according to the path selection rule already described. . Then, the selection unit 22 associates the branch condition acquired in the process of step S302 with the selected true / false value and stores it in a predetermined area of the memory 44, for example. Then, the branch selection process shown in FIG.

  As described above, the test case generation process shown in FIG. 18 is executed on the computer 40.

  As described above, in the test case generation apparatus 10 according to the present embodiment, the detection unit 26 detects a path candidate that overlaps with an existing path before the path search, and eliminates the overlapping path candidate in advance before the path search. Therefore, the test case generation device 10 according to the present embodiment can shorten the test case generation time compared to the case where the detection unit 26 is not included. In addition, since the detection unit 26 eliminates redundant path candidates in advance, the test case generation apparatus 10 according to the present embodiment performs branch coverage with a smaller number of paths compared to a conventional path extraction method such as DART. The path to be realized can be extracted.

  (Second Embodiment)

  Next, a second embodiment of the disclosed technique will be described. In addition, the same code | symbol is attached | subjected to the part same as 1st Embodiment, description is abbreviate | omitted, and it demonstrates centering on a different part from 1st Embodiment.

  FIG. 22 shows a test case generation device 10A according to the present embodiment.

  The test case generation device 10A according to the present embodiment is different from the test case generation device 10 in the first embodiment shown in FIG. 7 in that the management unit 20 is changed to the management unit 20A, and the others are the same. Therefore, explanation is omitted.

  FIG. 23 is a diagram showing an example of a program under test 30 in which a conditional branch instruction is included in external processing.

  In the inspected program 30 shown in FIG. 23, the 19th to 26th lines are external processes, and the 20th line includes an IF statement. The external process is called from three PERFORM statements on the 12th, 14th and 16th lines.

  In this case, when the management unit 20A analyzes the program to be inspected 30 in the initial state and detects an IF statement on the 20th line, the number of branch executions of the IF statement is determined as in the management unit 20 in the first embodiment. For example, initialization is performed as “direct = (0, 0)”.

  When the control unit 16 searches for the path of the program 30 to be inspected, first, external processing is called from the PERFORM statement on the 12th line. Then, according to the path selection rule, the THEN branch of the IF statement on the 20th line is executed, and the execution destination returns to the caller of the external process.

  At this time, the management unit 20A manages the number of times of IF statement branch execution for each caller of the external process. Specifically, when an IF statement is executed by an external process call from the first caller, the number of branch executions such as “Perform # 12 = (1, 0)” is recorded. Here, 'Perform' before '#' represents a command statement that called the external process, and the numerical value of '12' following '#' represents the call source line number of the external process.

  Subsequently, when the external process is called from the PERFORM statement on the 14th line, the THEN branch of the IF statement on the 20th line is executed according to the path selection rule, and the process returns to the caller of the external process. At this time, the management unit 20A records the number of branch executions such as “Perform # 14 = (1, 0)” because the external process is called from a different call source.

  Furthermore, when an external process is called from the PERFORM statement on the 16th line, the THEN branch of the IF statement on the 20th line is executed according to the path selection rule, and the process returns to the caller of the external process. At this time, the management unit 20A records the number of branch executions such as “Perform # 16 = (1, 0)” because the external process is called from a different call source.

  That is, direct = (0, 0), Perform # 12 = (1, 0), Perform # 14 = (1, 0), with respect to the IF statement on the 20th line of the inspected program 30 shown in FIG. And the number of branch executions of Perform # 16 = (1, 0) is managed.

  Next, the operation of the test case generation device 10A according to the present embodiment will be described. The test case generation process of the test case generation apparatus 10A is the same as the test case generation process of the test case generation apparatus 10 in the first embodiment shown in FIG. However, since the contents of the branch execution number management process in step S116 are different, the branch execution number management process according to the present embodiment will be described below.

  FIG. 24 is a flowchart showing the contents of the branch execution count management process performed by the management unit 20A. The branch execution number management process shown in FIG. 24 is different from the branch execution number management process shown in FIG. 20 in that the processes of step S403, step S406, and step S408 are added. Since the other processes are the same as the branch execution frequency management process shown in FIG.

  In step S403, the management unit 20A determines whether or not the conditional branch instruction read by the control unit 16 in the process of step S112 shown in FIG. 18 is a conditional branch instruction read by an external process call. Specifically, the determination may be made with reference to the execution path of the program to be inspected 30 recorded in the memory 44 in the process of step S120.

  If the determination in step S403 is negative, the process proceeds to step S404 already described. On the other hand, if the determination is affirmative, the process proceeds to step S406.

  In step S406, the management unit 20A refers to the execution path of the program to be inspected 30 recorded in the memory 44 in the process of step S120, and sets the subroutine hierarchy of the conditional branch instruction read in the process of step S112 shown in FIG. get.

  Here, the subroutine hierarchy of the conditional branch instruction indicates a calling process of external processing up to the conditional branch instruction.

  For example, a subroutine when the external process A is called from the PERFORM statement on the N1 line, the external process B is further called from the PERFORM statement on the N2 line included in the external process A, and the external process B includes a conditional branch instruction The hierarchy will be described.

  In this case, since the conditional branch instruction is called in the order of the external process A and the external process B, the subroutine hierarchy of the conditional branch instruction uses, for example, the line number of the caller of the external process, “Perform # (N1, N2) Is acquired.

  If the conditional branch instruction is included in the external process A called from the PERFORM statement on the N1th line, the subroutine hierarchy of the conditional branch instruction is “Perform # N1” as already described in FIG. Is acquired.

  In step S408, the management unit 20A increases the branch execution count of the conditional branch instruction corresponding to the subroutine hierarchy by one based on the branch destination of the conditional branch instruction acquired in step S402, for example, the memory 44 Is stored in a predetermined area.

  As described above, the branch execution frequency management process of step S116 shown in FIG. 18 is executed by the processes of steps S400 to S408.

  As described above, in addition to managing the number of branch executions for each conditional branch, the management unit 20A according to the present embodiment further includes a conditional branch instruction that is included in the external processing until the conditional branch instruction is reached. Manages the number of branch executions for conditional branches for each caller of the external process that has passed through.

  Therefore, when the program to be inspected 30 includes a conditional branch in the external process, it is possible to generate a test case that realizes branch coverage more efficiently than when the number of branch executions is simply managed for each conditional branch. .

  Although the disclosed technique has been described using the embodiment, the disclosed technique is not limited to the scope described in the embodiment. Various changes or improvements can be added to the above-described embodiment without departing from the gist of the disclosed technology, and forms to which the changes or improvements are added are also included in the technical scope of the disclosed technology. For example, the order of the processes shown in FIGS. 18 to 21 and FIG. 24 may be changed without departing from the gist of the disclosed technology.

  In the above description, the test case generation program 50, which is an example of the test case generation program according to the disclosed technology, is stored (installed) in the storage unit 46 in advance. However, the present invention is not limited to this. The test case generation program according to the disclosed technology can also be provided in a form recorded on a computer-readable recording medium. For example, the test case generation program according to the disclosed technology is provided in a form recorded in a portable recording medium such as a CD-ROM, a DVD-ROM, and a USB memory, and a semiconductor memory such as a flash memory. Is also possible.

  Further, the test case generation devices 10 and 10A disclosed in the embodiment have been described as being realized on the single computer 40. However, the process may be stored in the storage unit 46 of a different computer, and the test case generation apparatuses 10 and 10A may be realized in the form of distributed processing in which each computer is connected by a wired or wireless communication line.

  Further, the test case generation apparatuses 10 and 10A disclosed in the embodiment take a so-called network service mode in which the inspected program 30 is received via the network and the generated test case is output via the network. May be.

  The following additional notes are further disclosed regarding the embodiment including the first embodiment and the second embodiment.

(Appendix 1)
A management unit for managing the number of branch executions to the branch destination of the conditional branch included in the program to be inspected;
Comparing the branch information corresponding to the route candidate obtained from the number of branch executions managed by the management unit with the branch information corresponding to the already extracted route of the program to be inspected, the route candidate is A detection unit for detecting whether the route is an overlapping route included in the already-existing route;
A selection unit that determines a branch destination based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and selects a path from the start to the end of the program to be inspected;
A generation unit that generates branch information corresponding to the route selected by the selection unit as branch information corresponding to the already-explained route;
When the detection unit detects that the route candidate is not the overlapping route, processing by each of the selection unit and the generation unit is executed, and the detection unit detects that the route candidate is the overlapping route. A control unit that controls the selection unit and the generation unit so that processing by each of the selection unit and the generation unit is not executed,
A test case generation device having:

(Appendix 2)
When the conditional branch is a conditional branch included in a subroutine called from the call source of the program to be inspected, the management unit sets the number of branch executions corresponding to the conditional branch for each of the conditional branches. The test case generation device according to claim 1, wherein the test case generation device manages the branch execution count corresponding to the conditional branch for each caller of the subroutine.

(Appendix 3)
The control unit is calculated based on the number of branch executions managed by the management unit, the branch coverage before the selection of a new path by the selection unit, and the branch execution managed by the management unit The branch coverage after the selection of the new route by the selection unit calculated based on the number of times is compared, and the branch coverage after the selection of the new route is a branch before the selection of the new route If the coverage is the same, the generation unit is controlled not to generate branch information corresponding to the new route selected by the selection unit as branch information corresponding to the already-existing route. The test case generator described.

(Appendix 4)
Manage the number of branch executions to the branch destination of the conditional branch included in the program to be inspected.
The branch information corresponding to the route candidate obtained from the number of branch executions is compared with the branch information corresponding to the already-extracted route of the program to be inspected, and the route candidate is included in the already-existing route. Detect if it ’s a route,
When it is detected that the route candidate is not the overlapping route, a branch destination is determined based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and from the start to the end of the inspected program When a route is selected, branch information corresponding to the route is generated as branch information corresponding to the already-existing route, and when the route candidate is detected as the duplicate route, the route corresponding to the route candidate is selected. A test case generation method including controlling to not generate branch information corresponding to the route without selecting as branch information corresponding to the already-existing route.

(Appendix 5)
When the conditional branch is a conditional branch included in a subroutine called from the calling source of the program to be inspected, for each conditional branch, the branch execution count corresponding to the conditional branch is managed, and The test case generation method according to appendix 4, wherein the number of branch executions corresponding to the conditional branch is managed for each caller of the subroutine.

(Appendix 6)
Comparing the branch coverage before selecting a new route calculated based on the number of branch executions with the branch coverage after selecting a new route calculated based on the number of branch executions If the branch coverage after selecting the new route is the same as the branch coverage before selecting the new route, the branch information corresponding to the new route is changed to the branch information corresponding to the existing route. The test case generating method according to appendix 4 or appendix 5, wherein the test case is controlled so as not to be generated.

(Appendix 7)
On the computer,
Manage the number of branch executions to the branch destination of the conditional branch included in the program to be inspected.
The branch information corresponding to the route candidate obtained from the number of branch executions is compared with the branch information corresponding to the already-extracted route of the program to be inspected, and the route candidate is included in the already-existing route. Detect if it ’s a route,
When it is detected that the route candidate is not the overlapping route, a branch destination is determined based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and from the start to the end of the inspected program When a route is selected, branch information corresponding to the route is generated as branch information corresponding to the already-existing route, and when the route candidate is detected as the duplicate route, the route corresponding to the route candidate is selected. A test case generation program for executing processing including controlling to not generate branch information corresponding to the route as branch information corresponding to the already-existing route without selecting.

(Appendix 8)
On the computer,
Manage the number of branch executions to the branch destination of the conditional branch included in the program to be inspected.
The branch information corresponding to the route candidate obtained from the number of branch executions is compared with the branch information corresponding to the already-extracted route of the program to be inspected, and the route candidate is included in the already-existing route. Detect if it ’s a route,
When it is detected that the route candidate is not the overlapping route, a branch destination is determined based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and from the start to the end of the inspected program When a route is selected, branch information corresponding to the route is generated as branch information corresponding to the already-existing route, and when the route candidate is detected as the duplicate route, the route corresponding to the route candidate is selected. A computer-readable recording medium on which a program for executing a process including controlling to not generate branch information corresponding to the route as branch information corresponding to the already-existing route without selection is recorded .

10, 10A Test case generation device 12 Input unit 14 Symbolic execution unit 16 Control unit 18 Depth priority search unit 20, 20A Management unit 22 Selection unit 24 Generation unit 26 Detection unit 28 Output unit 30 Program to be tested 32 Test case 40 Computer 44 Memory 46 Storage unit 48 Bus

Claims (5)

A management unit that manages the number of branch executions to the branch destination of the conditional branch included in the program under test;
Comparing the branch information corresponding to the route candidate obtained from the number of branch executions managed by the management unit with the branch information corresponding to the already extracted route of the program to be inspected, the route candidate is A detection unit for detecting whether the route is an overlapping route included in the already-existing route;
A selection unit that determines a branch destination based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and selects a path from the start to the end of the program to be inspected;
A generation unit that generates branch information corresponding to the route selected by the selection unit as branch information corresponding to the already-explained route;
When the detection unit detects that the route candidate is not the overlapping route, processing by each of the selection unit and the generation unit is executed, and the detection unit detects that the route candidate is the overlapping route. A control unit that controls the selection unit and the generation unit so that processing by each of the selection unit and the generation unit is not executed,
A test case generation device having: When the conditional branch is a conditional branch included in a subroutine called from the call source of the program to be inspected, the management unit manages the number of branch executions corresponding to the conditional branch for each of the conditional branches. The test case generation device according to claim 1, wherein the branch execution count corresponding to the conditional branch is managed for each caller of the subroutine. The control unit is calculated based on the number of branch executions managed by the management unit, the branch coverage before the selection of a new path by the selection unit, and the branch execution managed by the management unit The branch coverage after the selection of the new route by the selection unit calculated based on the number of times is compared, and the branch coverage after the selection of the new route is a branch before the selection of the new route When the degree of coverage is the same, the generation unit is controlled so as not to generate branch information corresponding to the new route selected by the selection unit as branch information corresponding to the existing route. Item 3. The test case generation device according to Item 2. Manage the number of branch executions to the branch destination of the conditional branch included in the program to be inspected.
The branch information corresponding to the route candidate obtained from the number of branch executions is compared with the branch information corresponding to the already-extracted route of the program to be inspected, and the route candidate is included in the already-existing route. Detect if it ’s a route,
When it is detected that the route candidate is not the overlapping route, a branch destination is determined based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and from the start to the end of the inspected program When a route is selected, branch information corresponding to the route is generated as branch information corresponding to the already-existing route, and when the route candidate is detected as the duplicate route, the route corresponding to the route candidate is selected. A test case generation method including controlling to not generate branch information corresponding to the route without selecting as branch information corresponding to the already-existing route. On the computer,
Manage the number of branch executions to the branch destination of the conditional branch included in the program to be inspected.
The branch information corresponding to the route candidate obtained from the number of branch executions is compared with the branch information corresponding to the already-extracted route of the program to be inspected, and the route candidate is included in the already-existing route. Detect if it ’s a route,
When it is detected that the route candidate is not the overlapping route, a branch destination is determined based on a predetermined rule corresponding to the number of branch executions of the conditional branch, and from the start to the end of the inspected program When a route is selected, branch information corresponding to the route is generated as branch information corresponding to the already-existing route, and when the route candidate is detected as the duplicate route, the route corresponding to the route candidate is selected. A test case generation program for executing processing including controlling to not generate branch information corresponding to the route as branch information corresponding to the already-existing route without selecting.

Images