JPH05210537A - Test item preparing device - Google Patents

Abstract

PURPOSE:To prepare test items which pass through all paths of source codes. CONSTITUTION:A source code input part 2 inputs the source codes from a source code storage file 1. A branch retrieval part 3 retrieves the branch line of the source codes and a branch condition extraction part 4 extracts the branch conditions of the branch line. A test item extraction part 5 takes both true/false conditions of the branch conditions out and decomposes those conditions into expressions represented with only program input variables to extract the test items. A test item registration part 6 registers only test items, which are not in a test item storage part 7, in the test item storage part 7. A control part 8 executes respective parts 3-7 by branch lines in order and a test item output part 9 outputs the test items 10.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a system for creating test items for confirming software functions in a software development test process.

[0002]

2. Description of the Related Art In a software development test process, it is common to create a test item for confirming the function of software and perform a test according to the test item. Conventionally, this test item is manually created so that it passes through all branches while following the source code with eyes, or a technique of graphing and graphicalizing it so that missing or mistakes in the test item can be easily found visually. It was created by the tool used.

[0003]

However, since the test items created by the above-described creating method depend on the skill of each creator, some creators may see missing or missing test items. However, there was a problem that omissions or mistakes in the test items could cause deterioration of software quality.

In view of the above problems, it is an object of the present invention to provide a test item creation device that automatically creates test items that pass all paths of a source code without depending on the skill of the creator. It is a thing.

[0005]

A test item creating apparatus of the present invention includes a source code input section for inputting a source code, a branch search section for searching a branch line of the source code, and a branch condition extraction from the branch line. Branch condition extraction unit, a test item extraction unit that expresses both right and wrong conditions of the branch condition in an expression that is expressed only by program input variables, and further extracts a test item from the expression, and a test item storage unit that stores the test item A test item registration unit to be registered in the test item, a test item storage unit that stores the test item, a control unit that sequentially executes each unit for each branch line, and a test that outputs the test item stored in the test item storage unit. And an item output section.

[0006]

According to the above configuration, the branch line of the source code input from the source code input unit is searched by the branch search unit, and the text item extraction unit determines whether the branch condition extracted by the branch condition extraction unit is correct or not. Extracts test items by decomposing into an expression expressed only by program input variables whose values can be determined from outside the program, registers them in the test item storage section with the test item registration section, and outputs them as test items from the test item output section. Therefore, it is possible to create a test item that passes through all the paths of the source code as a test item that is represented only by the input variables.

[0007]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram of a test item creating apparatus according to an embodiment of the present invention. In the figure, 1 is a source code storage file, 2 is a source code input unit for inputting a source code, 3 is a branch search unit for searching a branch line of the source code, and 4 is a branch condition extraction unit for extracting a branch condition from the branch line. Reference numeral 5 is a test item extraction unit that expresses both right and wrong conditions of the branch condition in an expression expressed only by program input variables, and further extracts a test item from the expression, and 6 registers the test item in the test item storage unit 7. A test item registering unit, 7 a test item storing unit for storing test items, 8 a branch searching unit 3, a branch condition extracting unit 4, a test item extracting unit 5, a test item registering unit 6, and a test item storing unit 7. A control unit that sequentially executes each row, a test item output unit 9 that outputs the test items stored in the test item storage unit 7, and a test item 10 that represents the test items.

In this embodiment, the source code 49 will be described based on the C language source code 49 shown in FIG.

The source code storage file 1 is a file in which the source code 49 is stored.

The source code input unit 2 inputs the source code 49 from the source code storage file 1, and the control unit 8
Pass to.

The branch retrieval unit 3 receives the source code 49 from the control unit 8, retrieves the if statements in descending order from the last line of the source code, and sequentially passes the line numbers of the detected if sentences to the control unit 8.

The branch condition extraction unit 4 receives the source code 49 and the above-mentioned if statement line number from the control unit 8, extracts the branch condition from the if sentence, and passes the extracted branch condition to the control unit 8. The test item extraction unit 5 has the following functions. From the control unit 8, the source code 49, the if statement line number and the branch condition thereof are received. Find the reverse condition of the received branch condition. The source code 49 is an assignment statement that assigns a value (variable) to a variable used in a branch condition and its inverse condition.
The if statement is searched in descending order from the line immediately preceding the if sentence. Replace the value (variable) on the right side of the found assignment statement with the variable for the branch condition or its inverse condition. A test in which the branch condition and its inverse condition are represented by the arguments (a, b, c) of the function by repeatedly performing the descending order search of the if statement and the variable replacement work of the assignment statement up to the first line of the source code 49. Convert to item. The test items are passed to the control unit 8.

The test item registration unit 6 receives the test items from the control unit 8 and registers only the test items that are not in the test item storage unit 7 in the test item storage unit 7.

The test item storage unit 7 stores and holds the test items by the test item registration unit 6.

The control unit 8 has the following functions. The source code 49 is received from the source code input unit 2. The source code 49 is passed to the branch search unit 3, and if sentence line numbers are sequentially received. Source code 49 in the branch condition extraction unit 4
And the above if statement line number are passed, and the branch condition is received.
The source code 49, the if statement line number, and the branching condition are passed to the test item extracting unit 5, and the test item is received. The test items are passed to the test item registration unit 6. After registering test items for all if statements, all test items are fetched from the test item storage unit 7. All test items are passed to the test item output unit 9.

Thus, finally, the test item output unit 9
Output all test items. Next, the operation of this embodiment will be described focusing on the operation of the control unit 8. The overall process will be described with reference to the flowchart of the overall process in FIG. First, in process 11, the test item table in the test item storage unit 7 (shown in the transition diagram of the test item table in FIG. 9; 5
Initialize 9). Next, in process 12, the source code input unit 2 inputs the source code 49 from the source code storage file 1. Next, in process 13, the number of lines (18) of the source code 49 is counted and set to a variable 1 indicating the line number of the current process line. After that, the processes 14 to 19 are performed for all the lines of the source code 49. here,
The processing is performed in the descending order from the last line of the source code in order to reduce the number of test items that are repelled by the test item duplication check of the process 18 described later and to speed up the process. Next, in process 14, when 1 is greater than 0 (there are unprocessed lines), test items are generated by the processes of process 15 and subsequent processes, and when 1 is 0 or less (all lines are processed), process 20 is performed.
The test item is output with and the process ends. In processing 15, the branch search unit 3 performs processing 16 when one line is an if statement.
Then, the test item is added by the process 18 and when the one line is not an if statement, the process 19 is performed and the process of the next line is performed.
In process 16, the condition extracting unit 4 extracts the branch condition of the if statement. In process 17, the test item extraction unit 5 converts both the right and wrong conditions of the branch condition into an expression represented by the argument of the function, and sets it as a test item. In process 18, the test item registration unit 6 checks the duplication of the test items and registers only those test items that are not in the test item table 59 in the test item table 59 in the test item storage unit 7. In process 19, 1 is subtracted from 1 in order to move to the process of the next line, and the process returns to process 14. In process 20, the test item output unit 9 outputs all the test items as indicated by 60 stored in the test item table 59 to create the test item 10. In the case of the source code 49, the if statement to be processed first is the 13th line, and the branch condition of the 13th line fetched in the process 16 is (m <c: hereinafter referred to as condition A). [Test Item Extraction Process] Next, the above condition A (m <
The test item extraction process of c) will be described with reference to the flowchart of the test item extraction process of FIG. In this test item extraction processing, both right and wrong conditions of condition A (m <c, m ≧
From c), when executing an executable statement inside the if statement,
All cases in which no execution is performed are extracted and registered in the condition table 50 shown in the condition table transition diagram of FIG.

First, in process 21, the condition table 50 is initialized. Next, in process 22, 1 is set to each of the variable j indicating the current row of the condition table 50, the variable k indicating the registered column of the condition table 50, and the variable M indicating the registered row of the condition table 50. Next, in process 23, condition A (m <
c) is set to M rows and k columns (1 row, 1 column) of the condition table 50 to form a condition table 51. Next, in process 24, the reverse condition of condition A (m <c) (m ≧ c: hereinafter referred to as condition B) is obtained. Next, in process 25, 1 is added to the variable M (M = 2) in order to register the condition B in the line next to the condition A in the condition table. Next, in process 26, the condition B (m ≧ c) is set in the M rows and k columns (2 rows, 1 column) of the condition table to form the condition table. Next, in process 27, in order to extract all cases that pass the if statement as test items, condition A
A test item regarding (m <c) and a test item regarding condition B are searched. [Test Item Search Process] Next, the test item search process of the process 27 will be described with reference to the flowchart of the test item search process of FIG. 4 by taking the condition A (m <c) as an example. In this test item search process, the source code is searched and all cases where the condition A is satisfied are taken out as an expression represented only by the function arguments (a, b, c). First, in process 28, the search start row variable i is set to l-1 (12 rows).
Is set, and the source code is searched in the reverse direction from the line immediately preceding the target line. In process 29, if the search start line variable i is larger than 0 (when there is an unsearched source code), the process branches to process 30, and if the search start line variable i is 0 or less (when all the source codes are searched), a test The item search process 27 ends. In this case, i = 12 (>
Since it is 0), processing 30 is performed. In process 30, when the i-th row is an assignment statement, the process of changing variables after process 31 is performed,
When the i-th line is not an assignment statement, the process branches to step 36 to search for the next line. When the test item extracting process is performed on the 13th line of the source code 49, the first assignment statement processed is the 11th line (m = b), and the description of the process 31 and the subsequent steps will be given for the assignment statement (m = b). To do. In process 31, condition A (m <
When the left side (m) of c) is equal to the left side of row i, processing 33,
When the left side (m) of the condition A (m <c) is different from the left side of the i-th row, the process proceeds to the process 32 of replacing the left side of the process 34. In this case, the left side of condition A (m <c) and 11 lines (m =
Since the left sides of b) are equal, processing 33 is performed. Here, the assignment statement (m = b) is an execution statement inside the if statement (9th line),
Depending on whether the branch condition (m <b) is satisfied,
It depends on whether the above assignment statement is executed. Therefore, the condition A is decomposed and registered in the condition table when the if statement on the ninth line is satisfied or not satisfied. In process 33, the decomposition process for the assignment statement (m <b) of this condition A (m <c) is performed. In process 34, the left side (m) of condition A
And replace the right side (b) of the assignment statement. Process 32, Process 3
3, in the process 35, when the assignment statement is the assignment statement on the right side of the condition A, the condition A is the same as the processes 31, 33 and 34.
Then, the right side of condition A is replaced. Process 3
At 6, the variable 1 is subtracted from 1 and the process for the next line is performed. [Condition decomposition processing] Next, the condition A (m <
The decomposition process regarding the assignment statement (m = b) in c) will be described with reference to the flowchart of the conditional decomposition process in FIG.
The variables are as follows.

M = 2, i = 11, j = 1, k = 1 In the decomposition process of this condition, when the assignment statement (m = b) is an executable statement inside the if statement, the if statement is satisfied. The condition A registered in the condition table when the above condition is not satisfied is decomposed.

In process 37, if the i (11) line (m = b) is an assignment statement in the conditional statement, the process proceeds to step 38 and thereafter. If i line is not an assignment statement in the conditional statement, the condition is decomposed. The process ends. In this case, 11 lines (m = b) are 9 lines (i
Process 3 because it is an assignment statement in the conditional statement of f (m <b))
Do 8. In process 38, the branch condition (m <
b: hereinafter referred to as condition C). In the process 39, the condition C (m <b) is set in the jth row (1st row) and the k + 1th column (2nd column) of the condition table in order to set the first row of the condition table as the condition when the condition C is satisfied. And make a condition table. Next, in processing 40 to processing 43, the condition table 3
The condition when condition C is not satisfied is registered in the line.
In the process 40, 1 is added to the variable M (M = 3). In process 41, the same condition as condition A (m <c) (hereinafter referred to as condition D)
Is set in M rows (3 rows) and k columns (1 column) of the condition table to form a condition table. In process 42, condition C (m <
The reverse condition of b) (m ≧ b: hereinafter referred to as condition E) is obtained.
In the process 43, the above condition E (m ≧ b) is set to M rows (3 rows), k.
Set to +1 column (2 columns) to make a condition table. Next, the test item search processing is performed for the above-mentioned conditions C, D, and E in the processing after the processing 44, and each condition is made into an expression expressed only by the arguments of the function. In process 44, j is set to j and kk is set to k (jj = 1, kk =
1). In process 45, k is set to kk + 1 (k =
2). Next, in process 27, the search start line is set to 9 lines and condition C is set.
A test item search process regarding (m <b) is performed. Process 4
In step 6, M is set to j and kk is set to k (j = 3, k =
1). Next, in process 27, the search start line is set to 9 lines and the condition D is set.
A test item search process for (m <c) is performed. Process 4
At 7, kk + 1 is set to k (k = 2). Next, in process 27, a test item search process relating to condition E (m ≧ b) is performed with the search start line being 9 lines. When the test item search process is performed three times as described above, the left side (m) of condition C, condition D, and condition E is replaced by the right side (a) of the assignment statement by the assignment statement (m = a) in the eighth line, and the condition table 56. In process 48, jj is set to j and kk is set to k (j = 1, k =
1).

With the above processing, the condition decomposition process is completed. Next, in process 34, the left side (m) of condition A is the right side (b) of the assignment statement.
Is replaced with 57 in the condition table. As described above, the condition A is decomposed, and the new condition generated as a result of the decomposition is repeatedly subjected to the above-described test item search processing, so that the condition A is finally satisfied in all cases. It can be represented by an expression (test item) represented by only arguments (first and third rows of the condition table 57).

Next, the test item extraction processing as described above is also performed for the condition B (m ≧ c), and in all cases where the condition B is satisfied, an expression (test item) expressed only by the argument of the function
(The second and fourth rows of the condition table 58).

Finally, in process 18, the above conditions are registered as test items in the test item table 59 and are registered 60.
The items are shown in.

[0024]

As described above, according to the present invention, both right and wrong conditions for all branch lines of a source code are taken out, all of these conditions are expressed by an expression expressed only by program input variables, and they are used as test items. By doing so, it is possible to create a test item that passes all the paths of the source code.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a test item creation device according to an embodiment of the present invention.

FIG. 2 is a flowchart of the overall processing of the embodiment shown in FIG.

FIG. 3 is a flowchart of an extraction process of a test item extraction unit shown in FIG.

FIG. 4 is a flowchart of a search process of a test item extraction unit shown in FIG.

5 is a flowchart of a condition decomposition process of the test item extracting unit shown in FIG.

FIG. 6 is a diagram showing an example of the source code shown in FIG. 1 and test items.

7 is a transition diagram of a condition table of a test item storage unit shown in FIG.

8 is a transition diagram of a test item output condition table in the test item storage unit shown in FIG.

9 is a transition diagram of the test item table of the test item storage unit shown in FIG.

[Explanation of symbols]

 1 Source Code Storage File 2 Source Code Input Section 3 Branch Search Section 4 Branch Condition Extraction Section 5 Test Item Extraction Section 6 Test Item Registration Section 7 Test Item Storage Section 8 Control Section 9 Test Item Output Section 10 Test Items

Claims (1)

[Claims] 1. A system for creating a test item for confirming a software function in a software development test process, and a source code input section for inputting a source code and a branch search section for searching a branch line of the source code. , A branch condition extraction unit that extracts a branch condition from the branch line, and both the right and wrong conditions of the branch condition are expressed in an expression expressed only by a program input variable whose value can be determined from outside the program, and the test is performed from the expression. A test item extraction unit for extracting items, a test item registration unit for registering the test items in the test item storage unit, a test item storage unit for storing the test items, and a control for sequentially executing each unit for each branch line. Section and a test item output section for outputting the test item stored in the test item storage section described above. apparatus.