JP2001273169A - Device for generating program test specification - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program test specification generation which enables automatic extraction of a test item corresponding to significance. SOLUTION: This program test specification generation device is provided with a program analyzing part extracting a variable from in a program, a displaying part for displaying the variable extracted by the program analyzing part, an inputting part for inputting information specifying the variable, a test item extracting part extracting description including the variable specified by the information inputted from the inputting part from the program, and a specification generating part generating a program test specification in which the description extracted by the test item extracting part is defined as a test item.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to an apparatus and a method for generating a program test specification for generating a program test specification for performing a program test.

[0002]

2. Description of the Related Art Various tests are performed on a developed program to confirm whether the developed program operates normally. Here, as one mode of this test, a program test is performed in which a combination of parameters input at the time of execution of the program is changed, and whether or not the program passes a specific portion of the program scheduled at the time of design is checked.

[0005] Prior to a program test, a program test specification is created in which a portion of the program for checking whether or not the program has passed during execution of the program is expressed as a test item. The program test is performed based on this program test specification.

In some cases, a program as a new version of an existing program is developed in order to enhance the functions or maintain the existing program. In this case, a program test may be performed on the new version of the program in order to determine how much the corrected or added portion affects the existing portion.

At this time, it is necessary to prepare a program test specification for the purpose of the program test.

[0006]

However, the conventional program test specification is based on the fact that a person looks at a description of a program to be subjected to a program test, and confirms and extracts, one by one, portions which are deemed necessary to be tested. Was created by describing it as a test item. For this reason, great effort was required to create the program test specifications.

Although it is conceivable to reduce this effort by using a software tool or the like, conventional tools cannot extract test items according to importance. In the end, it was necessary to manually remove non-essential and redundant test items, and the use of tools did not reduce the effort.

The present invention has been made to solve such a problem, and an object of the present invention is to provide a program test specification generating apparatus capable of automatically extracting test items according to importance. .

[0009]

In order to solve the above-mentioned problems, a program test specification generating apparatus according to the present invention employs the following configuration.

(1) A program analysis unit for extracting variables from a program, a display unit for displaying the variables extracted by the program analysis unit, an input unit for inputting information for specifying the variables, and the input unit A test item extracting unit for extracting a description including a variable specified by information input from the unit from the program, and a specification for generating a program test specification using the description extracted by the test item extracting unit as a test item And a generation unit.

A program test specification is automatically generated when an operator designates a variable to be used for extracting a test item from variables automatically extracted from a program. As a result, it is possible to extremely easily create a program test specification.

(2) A program analyzer for extracting variable names and functions from a program, a display for displaying variables and functions extracted by the program analyzer, and information for specifying variables or functions. An input unit, a test item extraction unit that extracts a description including a variable or a function input from the input unit from the program, and a program test specification that uses the description extracted by the test item extraction unit as a test item. And a specification generation unit for generating the specification.

A program test specification is automatically generated by extracting both variables and functions from a program and designating an operator to use the variables and functions to extract test items from the program.

(3) In (1), the display unit displays the variables and functions extracted by the program analysis unit in order of their appearance frequency.

Since the variables extracted from the program are displayed in order of frequency, the operator can easily determine the importance of the variables.

(4) An appearance frequency calculating section for calculating the appearance frequency of the variable in the program, a display section for displaying the maximum occurrence frequency of the variable calculated by the appearance frequency calculation section, and an input of the appearance frequency level. An input unit, a test item extraction unit that extracts from the program a description including a variable of an appearance frequency equal to or higher than the appearance frequency level input to the input unit, and a description extracted by the test item extraction unit as a test item. And a specification generation unit that generates a program test specification to be executed.

Just by the operator designating the appearance frequency level, a variable having an appearance frequency equal to or higher than the designated appearance frequency level is selected, and a program test specification having a description including the variable as a test item is automatically generated. Is done.

(5) an appearance frequency calculating section for calculating the appearance frequency of variables and functions in the program; a display section for displaying the maximum occurrence frequency of the variables and functions calculated by the appearance frequency calculation section; An input unit for inputting each appearance frequency level, a test item extraction unit for extracting a description including a variable or function of an appearance frequency equal to or higher than the respective appearance frequency level input to the input unit from the program, A specification generation unit that generates a program test specification using the description extracted by the test item extraction unit as a test item.

By specifying an appearance frequency level for each of the variable and the function, a variable or function having an appearance frequency equal to or higher than the respective appearance frequency level can be automatically selected. Since the appearance frequency level can be separately specified for the variable and the function, a program test specification can be automatically generated in which each importance is individually considered.

(6) In (4) or (5), the input section is for further inputting information for specifying a variable or a function, and the test item extracting section is provided for the input section. A description including a variable or a function specified by the input information is extracted from the program.

Since the variable can be directly specified together with the specification of the appearance frequency level, a test item that reflects the importance of the variable more precisely is selected when generating the program test specification.

(7) In (4) to (6), the display unit displays the variables and functions extracted by the program analysis unit in the order of their appearance frequencies.

The display of the variables in the order of appearance frequency makes it easy to determine the appearance frequency level or the variables themselves.

(8) A syntax tree generating section for generating a syntax tree representing a control structure of a program, an input section for inputting a nest level, and a section having a nest level higher than the nest level input to the input section From the program, and a specification generator that generates a program test specification using the description extracted by the test item extractor as a test item.

By generating a syntax tree in advance, a portion having a nesting level higher than a specified nesting level can be automatically extracted from a program.

(9) A difference program generator for extracting a difference from the first program to the second program to generate a difference program, a program analyzer for extracting variables from the difference program, A test item extracting unit for extracting a portion including a variable extracted by the analyzing unit from the first program, and a specification generating unit for generating a program test specification using the description extracted by the test item extracting unit as a test item And a unit.

A part added or changed from the first program is automatically extracted from the first program, a variable included in the added or changed part is extracted, and a description including the variable in the first program is included. Is a test item.

As a result, it is possible to generate a program test specification suitable for judging the influence of the portion added or changed in the first program on the operation of the same portion as the second program.

[0029]

(First Embodiment) FIG. 1 shows a first embodiment of the present invention. FIG. 1 is a block diagram showing the configuration of the present embodiment.

As shown in FIG. 1, the program test specification generating apparatus according to the present embodiment includes a program analyzing unit 11, an input unit 12, a test item extracting unit 13, and a specification generating unit 14.

The program test specification generating apparatus generates a program test specification 17 from the program 15, and generates a variable / function file 16 containing a list of variables and functions as an intermediate process.

FIG. 2 is a flowchart showing the flow of processing in this embodiment.

The program analysis unit 11 includes a program 15
Are extracted from the data and output as the variable / function file 16 (S21). The contents of the variable / function file 16 are displayed on a display or the like as necessary (S22).

Variables and functions for extracting test items are designated and input to the input unit 12 (S23). Here, the operator selects and inputs variables and functions considered to be important from the variable / function file 16.

The test item extraction unit 13 includes a program 15
Then, the part using the variables and functions input from is extracted and sent to the specification generator 14 (S24). Specification generation unit 14
Outputs the program test specification 17 (S25).

FIG. 3 is a flowchart for explaining the procedure for extracting variables and functions in S21 in more detail. A variable or function declaration is searched from the program 15 and is additionally written in the variable / function file 16 together with the line number of the declaration.

As shown in FIG. 3, a variable line indicating a line number is set to 0 (S31). Then, one line of the program 15 is read by the program analysis unit 11 (S32). Since one line of the program 15 has been read, 1 is added to the variable line. And
It is determined whether the read line contains a function or variable declaration statement (S34).

If the determination is Yes, the variable or function name is added to the variable / function file 16 together with the variable line indicating the line number (S35). At this time,
When a plurality of variables are declared in one line, the variables are decomposed for each variable and entered in the variable / function file 16.

If the determination in step S34 is No, the processing in step S35 is not performed.

It is determined whether the last line of the program has been reached and the next line does not exist (S35).
In the case of s, the variable / function extraction process ends (S3
7). If the determination in step S35 is No, the process returns to step S32 and continues.

When the variable / function extraction processing is completed, the variables and functions in the variable / function file 16 are sorted as necessary to facilitate listing.

FIG. 3 shows an example of a program language, such as the C language, which must be declared when using variables and functions. It goes without saying that in a language that can use variables without declaration, variables and functions should be extracted from sources other than the declaration statement.

FIG. 4 shows an example of a program test specification generated according to the present embodiment. FIG. 4 is an example in which a row including the variable y is extracted as a test item. The test items are item contents of numbers 1-1, 1-2, 2-1-1, and 1-2-2, for example, “y = a + b;”. In addition, number 1,
2, 2-1 are described as test item delimiters.

As described above, in this embodiment, all the variables and functions used in the program are automatically extracted, and the variables for which it is determined that the user needs to perform the program test are determined. , A function to specify a function.

The variable designated by the user
All test items related to functions can be extracted from the program, and a program test specification can be automatically generated.

(Second Embodiment) FIG. 5 shows a second embodiment of the present invention. FIG. 5 is a block diagram illustrating a configuration of the program test specification generation device according to the present embodiment.

As shown in FIG. 5, the program test specification generating apparatus according to the present embodiment comprises a program analyzing section 61, an input section 62, a test item extracting section 63, and a specification generating section 64.

The program test specification generating device generates a program test specification 67 from the program 65. As an intermediate process, a variable file 66 in which a list of variables is described in order of frequency is generated.

FIG. 6 is a flowchart showing the flow of processing in this embodiment.

The program analysis section 61 includes a program 65
And outputs it to the temporary variable file 68 (S
71). Then, the extracted variables are stored in the program 6
5 is calculated.

Based on the result, the variable temporary file 6
8 are rearranged in order of frequency, and a variable file 66 in which variables are arranged in order of appearance frequency is generated. The contents of the variable file 66 are displayed on a display or the like as necessary (S73). Note that this display method includes (1) displaying the variable names themselves in order of frequency, (2) displaying only the maximum value of the appearance frequency, and (3) displaying the distribution of the appearance frequency (for example, the horizontal axis Various methods are conceivable, such as displaying a graph in which the number of occurrence frequencies is plotted on the vertical axis and the number of variables having the appearance frequency is taken).

A frequency level for extracting test items is designated and input to the input section 62 (S74). The frequency level is a boundary value for selecting a variable used for test item extraction. The frequency level is determined by the operator in step S73.
Is determined in consideration of the display and the like.

The test item extracting section 63 is a program
Then, a portion using a variable having an appearance frequency equal to or higher than the frequency level input from is extracted and sent to the specification generating unit 64 (S75). The specification generator 14 outputs the program test specification 17 (S76).

Step S71 is the same as in the first embodiment.
It can be realized by the flow of FIG.

FIG. 7 is a flowchart for explaining in more detail the procedure of calculating the frequency of appearance of variables in step S72.

First, the program analysis section 61 reads the temporary variable file 68 generated in S71 (S8).
1). Then, a variable Ni (N1, N1,
, Nn) are all set to 0 (S82). Here, n is the number of variables, and i is a suffix representing each variable.

One line of the program 65 is read by the program analyzer 61 (S83). Then, it is determined whether the read line includes any variable (S
84).

If the determination is Yes, 1 is added to Ni for the variables included in the row (S85). Here, i is appropriately selected from a single or a plurality from 1 to n according to the variables included in the row.

Next, it is determined whether or not the program reaches the last line and the next line does not exist (S86). If the determination is Yes, the variable appearance frequency calculation processing ends (S87). Upon completion, the variables in the variable temporary file 68 are rearranged in descending order of Ni corresponding to each variable. If the determination in step S86 is No, S
Returning to 83, the processing is continued.

As described above, it is possible to select a variable on the basis of the frequency of appearance, and extract a part including this variable from the program 65 as a test item.

In the present embodiment, the calculation of the appearance frequency is performed only for the variables. However, the calculation of the appearance frequency together with the function or the function alone and the extraction of the part using the function are performed. It goes without saying that it can be done.

Further, it goes without saying that in step S 74, the variable itself can be input irrespective of the frequency level together with the input of the frequency level, and the description including the variable input in step S 75 can be extracted from the program 65.

As described above, in the present embodiment, variables appearing in a program are extracted, the appearance frequency is calculated and displayed,
A mechanism is added for the user to specify a variable according to the frequency of appearance.

As a result, a corresponding description can be extracted from the program as a test item without fail for variables that appear complicated in the program.

As described above, in this embodiment, the program test specification can be automatically generated, and the number of steps for preparing the program test specification can be reduced.

(Third Embodiment) FIG. 8 shows a third embodiment of the present invention. FIG. 8 is a block diagram showing the configuration of the present embodiment.

As shown in FIG. 8, the program test specification generating apparatus according to the present embodiment includes a program analyzing section 91, an input section 92, a test item extracting section 93, and a specification generating section 94.

A program test specification 97 is created from the program 95 by the program test specification generator, and a syntax tree file 96 in which a syntax tree is described is generated as an intermediate process.

FIG. 9 is a flowchart showing the flow of processing in this embodiment.

The program analyzing section 91 includes a program 95
, The nesting state of the program is analyzed and output as a syntax tree file 96 indicating the control structure of the program, that is, the correspondence between the program line and the nest number (S1).
01). The details of the syntax tree will be described later.

A nest level for extracting test items is designated and input to the input section 92 (S102). The nest level is a boundary value for determining a test item extraction range.

The test item extracting section 93 is a program
Then, a portion having a nest number equal to or greater than the nest level input from is extracted from the program 95 and sent to the specification generating unit 14 (S103). The specification generator 94 generates and outputs a program test specification 97 (S1045).

FIG. 10 is a program list for explaining the concept of a syntax tree, and shows the correspondence between programs and nest numbers.

As shown in FIG. 10, the program is described together with the line numbers. Here, the numerical value on the right side of FIG. 10 is the nesting number, and indicates the nesting depth of each row. Here, the expression representing the correspondence between the program lines and the nesting depth is called a syntax tree.

That is, the syntax tree indicates the depth of the control structure of the program. Since the line numbers 1 to 4 are not incorporated in the control structure, the nest number is 0. However, since the line numbers 5 to 9 are within the range of the control structure of the if statement, the nest number is 1. Since the range of line numbers 10 to 12 is out of the control range of the if statement of line number 5 described above, the nest number is 0. Further, line numbers 13 to 25 correspond to line number 1
Since the control range of the while statement is 3, the nest number is at least one. Of these, the range of line numbers 15 to 23 is also the control range of the if sentence of line number 15, so the number of nests is at least two. Furthermore, among these, the range of line numbers 18 to 22 is also the control range of the if sentence of line number 18, so that the nest number is 3.

As described above, the number of nests shown in FIG. 10 indicates how many control structures each row is incorporated in. If there is a program defect where the number of nests is large, the effect is extremely large. That is, the nest number can be used as a measure indicating the importance of each row in a sense.

For example, if 2 is input as the nest level in step S102, the range of line numbers 15 to 23 with the nest number of 2 or more is extracted in S103. However, since the line numbers 17, 20, 22, and 23 are non-executable statements, they are excluded as test items.

FIG. 11 is a flowchart for explaining the syntax tree file generation procedure in S101 in more detail.

First, the variable line representing the line number and the count representing the nesting number are set to 0 (S12).
1).

The program analysis section 91 has a program 95
Is read in one line (S122). Then, 1 is added to line in response to reading of one row (S123).

Then, it is determined whether or not the read line is the beginning of the control structure (for example, if statement, while statement, etc.) (S124). If this determination is Yes, c
“1” is added to “out” (S125).

If the determination in step S124 is No,
It is determined whether or not the read line is the end of the control structure (S126). If the determination is Yes, 1 is subtracted from count (S127). If the determination in S126 is No, the process proceeds to the next step (S128).

After steps S125 and S127, li
A pair of ne and count is additionally written in the syntax tree file 96 (S129).

Next, it is determined whether the read line is the last line of the program (S129). Step S129
If the determination is Yes, the syntax tree generation process ends, and if the determination is No, the process returns to S122 and continues.

Thus, the program line number (l
Ine) and the corresponding nest number (count) are sequentially added to the file, and a syntax tree file 96 is generated.

The program test specification is the same as that of the first embodiment, so that the description is omitted.

As described above, in the present embodiment, the user specifies the nesting level indicating the complexity of the control structure of the program, and extracts the description in the program for the control structure which is more complicated than the test item. It has a mechanism to be.

Therefore, in a program test for a developed program, a description of a complexity or more selected by a user is extracted as a test item, and a program test specification can be automatically generated.

As a result, an efficient program test can be performed.

(Fourth Embodiment) FIG. 12 shows a fourth embodiment of the present invention. FIG. 12 is a block diagram showing the configuration of the present embodiment.

As shown in FIG. 12, the program test specification generating apparatus according to the present embodiment comprises a first program analyzing section 131, a second program analyzing section 132, a test item extracting section 133, and a specification generating section. 134.

The program test specification 13 of the new version of the program 136 by the program test specification generation device
9 is generated as an intermediate process, a difference program file 137 of the existing version program 135 and the new version program 136 and a variable file 138 extracted from the difference program file 137 are generated.

FIG. 13 is a flowchart showing the flow of processing in this embodiment.

The first program analysis section 141 generates a difference program file 137 by extracting the difference between the existing version program 135 and the new version program 136 (S141).

Then, the second program analyzer 132 extracts the variables used in the difference program file 137 (S142).

Further, the test item extracting section 133 extracts a portion using the variable extracted from the difference program file from the new version program 136 and sends it to the specification creating section 14 (S143). The specification generator 134 generates and outputs the program test specification 139 (S14).
4).

Next, the difference program file 1 in S141
The procedure for generating 37 will be described in more detail. The difference program file 137 is a file in which a result of extracting a part different from the existing version program 135 from the new version program 136 is recorded, and this difference is classified as follows.

(1) When a new line is added (or inserted) to the existing program 135 (2) When the contents of the line of the existing program 135 are changed (3) When the line of the existing program 135 is deleted The program file 137 includes (1)
It is created by extracting the part where (2) is added or changed.

(3) need not be detected as such. However, the new version program 136 is actually (1)
(3), it is necessary to classify (1) to (3) when generating the difference program file 137.

The extraction of variables from the difference program file 137 in step S142 will be further described.

The variables used in the difference program file 137 can be classified into the following two types.

(1) Variables used only in addition and change of new version program 136 (2) Variables used in common in addition and change of new version program 136 and existing version program 135 (1) When the test items are extracted from the new version program 136 using the variables in ()), the addition of the new version program 136,
A program test specification 139 specialized for a changed part can be generated.

The extraction of variables at this time can be performed by detecting the presence or absence of a variable declaration statement as shown in FIG. 3 in the first embodiment.

New version program 1 using variables in (2)
When the test items are extracted from 36, the new version program 13
6 can be generated to generate a program test specification 139 suitable for determining how to affect the operation state of the existing part.

The extraction of the common variables from the difference program file 137
After all of the variables used in step (1) are extracted, the variable declared in the difference program file 137 can be removed.

(3) Further, a test item can be extracted from the new version program 136 by using both the variables (1) and (2).

At this time, it is possible to generate a program test specification 139 for determining both the addition and change of the new version program 136 and the effect of the addition and change on the existing part.

In this case, the difference program file 137
By extracting all the variables used from, the variables can be extracted.

As described above, there are three ways to extract variables. However, when simply extracting variables from the difference program file 137, the third case of extracting all variables is a general case.

As described above, in this embodiment, the new version program 136 is added to the existing version program 135,
Descriptions about variables that appear in the changed description are extracted from the new version of the program and used as test items.

For this reason, it is possible to automatically extract, from the new-version program, a part affected by a variable newly included in the description of the program added or modified in the new-version program to create a program test specification. it can.

This program test specification is a program test specification that can be used for a regression test for checking how much the addition or modification of a new version program affects the operation of the program.

[0113]

As described above, according to the present invention,
It is possible to provide an apparatus for creating a program test specification that enables automatic extraction of test items according to importance.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration according to a first embodiment of the present invention.

FIG. 2 is a block diagram showing a processing flow according to the first embodiment of the present invention.

FIG. 3 is a flowchart for explaining a procedure of extracting variables and functions in FIG. 2 in more detail;

FIG. 4 is a diagram showing an example of a program test specification generated according to the first embodiment of the present invention.

FIG. 5 is a block diagram showing a configuration according to a second embodiment of the present invention.

FIG. 6 is a block diagram showing a processing flow according to a second embodiment of the present invention.

FIG. 7 is a flowchart for explaining in more detail a procedure of calculating the appearance frequency of a variable in FIG. 6;

FIG. 8 is a block diagram showing a configuration according to a third embodiment of the present invention.

FIG. 9 is a block diagram showing a flow of processing according to a third embodiment of the present invention.

FIG. 10 is a program list for explaining the concept of a syntax tree.

FIG. 11 is a flowchart for explaining the syntax tree generation procedure in FIG. 9 in more detail;

FIG. 12 is a block diagram showing a configuration according to a fourth embodiment of the present invention.

FIG. 13 is a block diagram showing a processing flow according to a fourth embodiment of the present invention.

[Explanation of symbols]

 Reference Signs List 11 program analysis unit 12 input unit 13 test item extraction unit 14 specification generation unit 15 program 16 variable / function file 17 program test specification 61 program analysis unit 62 input unit 63 test item extraction unit 64 specification generation unit 65 program 66 variable File 67 program test specification 68 variable temporary file 91 program analysis unit 92 input unit 93 test item extraction unit 94 specification generation unit 95 program 96 syntax tree file 97 program test specification 131 first program analysis unit 132 second program Analysis unit 133 Test item extraction unit 134 Specification generation unit 135 Existing version program 136 New version program 137 Difference program file 138 Variable file 139 Program test specification

Claims (10)

[Claims] 1. A program analysis unit for extracting a variable from a program, a display unit for displaying a variable extracted by the program analysis unit, an input unit for inputting information for specifying a variable, and the input unit A test item extracting unit for extracting a description including a variable specified by information input from the program from the program, and a specification generating unit for generating a program test specification using the description extracted by the test item extracting unit as a test item And a program test specification generation device. 2. A program analysis unit for extracting variable names and functions from a program, a display unit for displaying variables and functions extracted by the program analysis unit, and a unit for inputting information for specifying variables or functions. An input unit, a test item extracting unit that extracts a description including a variable or a function input from the input unit from the program, and a program test specification in which the description extracted by the test item extracting unit is used as a test item. A program test specification generation device, comprising: 3. The test specification generator according to claim 1, wherein the display unit displays the variables and functions extracted by the program analysis unit in the order of their appearance frequency. 4. An appearance frequency calculation unit for calculating an appearance frequency of a variable in a program, a display unit for displaying a maximum occurrence frequency of a variable calculated by the appearance frequency calculation unit, and an input unit for inputting an appearance frequency level. An input unit, a test item extraction unit that extracts from the program a description including an occurrence frequency variable equal to or higher than the appearance frequency level input to the input unit, and a description extracted by the test item extraction unit as a test item. A program test specification generation device, comprising: a specification generation unit that generates a program test specification. 5. An appearance frequency calculation unit for calculating the appearance frequency of a variable and a function in a program; a display unit for displaying the maximum occurrence frequency of the variable and the function calculated by the appearance frequency calculation unit; An input unit for inputting an appearance frequency level of a test item; a test item extraction unit for extracting a description including a variable or a function of an appearance frequency equal to or higher than the respective appearance frequency level input to the input unit from the program; A program test specification generation device, comprising: a specification generation unit that generates a program test specification having a description extracted by an item extraction unit as a test item. 6. The input unit is for further inputting information for specifying a variable or a function, and the test item extracting unit is for inputting the variable or the function specified by the information input to the input unit. The program test specification generation device according to claim 4, wherein a description including a function is extracted from the program. 7. The test specification according to claim 4, wherein the display unit displays the variables and the functions extracted by the program analysis unit in the order of their respective appearance frequencies. Document generator. 8. A syntax tree generating section for generating a syntax tree representing a control structure of a program, an input section for inputting a nest level, and a section having a nest level higher than the nest level input to the input section. A test item extracting unit that extracts from the program using the syntax tree; and a specification generating unit that generates a program test specification using the description extracted by the test item extracting unit as a test item. A program test specification generation device characterized by the following. 9. A difference program generation unit that extracts a part different from the second program from the first program to generate a difference program, a program analysis unit that extracts a variable from the difference program, and the program analysis A test item extracting unit for extracting a portion including a variable extracted by the unit from the first program, and a specification generating unit for generating a program test specification using the description extracted by the test item extracting unit as a test item A program test specification generation device, comprising: 10. The program test specification generating apparatus according to claim 9, wherein the first program has a newer version than the second program.