JP4483163B2 - Program test debugging device - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a test in software development including software used in a business field, and more particularly to a test debugging method suitable for reducing the number of steps in a test process.
[0002]
[Prior art]
A conventional test debugging method or apparatus provides a coverage information accumulation file for an existing completed or semi-completed program, sets information that has been executed for each instruction sentence in the coverage information accumulation file, and then changes the program. In contrast, there is known a differential test debugging support method characterized in that only the coverage information of the changed part is set to a test unexecuted state and only the changed part of the statement is executed as a test target (for example, (See Kaihei 6-103113).
[0003]
However, in the present invention, a method of performing some measures for acquiring coverage information on an existing completed or semi-completed program including known examples and storing the coverage acquisition result in the coverage information accumulation file. Is not disclosed. According to the prior art, the coverage information acquisition work known to those skilled in the art as C0 major and C1 major is carried out as a desktop debugging, etc. There has been a problem that the check work by manual work is required for every command statement of the program by a known manpower, which increases the number of test work steps.
[0004]
[Patent Document 1]
JP-A-6-103113 (summary, FIG. 2)
[0005]
[Problems to be solved by the invention]
An object of the present invention is to perform a test execution status check of all the statements of the program mechanically by a compiler or the like in order to reduce test man-hours in test debugging of system development work, The goal is to improve the productivity of program development by reducing the number of test debugging work steps.
[0006]
[Means for Solving the Problems]
The above purpose is
(1) means such as a file for storing an existing completed or semi-completed program composed of a declaration statement, a command statement and a comment corresponding to one compiler specification (herein called a test target program storage file);
(2) means such as a file for copying and storing the contents of the test target program storage file (herein called the coverage test ready program file);
(3) Analyzing the existing completed or semi-completed program stored in the coverage test ready program file into “instruction statement” units and “instruction statements including branches” as “instruction statements and branch units within them”. In addition, an identifier unique to the program (herein referred to as an instruction branch serial number in the program) is added to the “instruction sentence” and “an instruction sentence including a branch or the like is an instruction sentence and a unit of branch in the instruction sentence”. The coverage information accumulation file is stored together with a symbol indicating a result of classification such as an instruction or an instruction internal branch (herein referred to as a C0 target C1 target classification symbol) (herein referred to as a source analysis function), and the coverage test ready program file A coverage passing function is generated for each instruction branch sequence number in the program in a format that can be interpreted by the compiler described in (5) below. And means for embedding a part of the program and (referred to herein as the source analysis-embedded program),
(4) means such as a file (herein referred to as a coverage information storage file) for recording the C0 target C1 target classification symbol and the execution result of the following coverage passing function in association with the instruction branch serial number in the program;
(5) A coverage information storage file that exists in a format that can be interpreted by the compiler, etc., is uniquely generated for each instruction branch serial number in the program, and is executed when called (coverage passing symbol). This is achieved by providing means such as a function for storing the function (herein referred to as a coverage passing function).
[0007]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, the present invention will be described in detail based on an embodiment.
FIG. 1 is a block diagram showing the configuration of a computer that implements the present invention, which comprises a CPU 101, a memory 102, an external storage device 103, an input device 104, a display device 105, and a printer 106.
[0008]
FIG. 2 is a schematic diagram of this embodiment. 202 refers to a source program 201 that is an existing completed or semi-completed program to be tested, which is stored in a test target program storage file, which will be described later with reference to FIG. 3, and copies the contents of the source program 201. FIG. 4 explains the function stored in the coverage test ready program file 203, which will be described later as an explanation of FIG. 7, and the source program that is an existing completed or semi-completed program stored in the coverage test ready program file 203 by the function. As will be described later, the source program which is the existing completed or semi-completed program is analyzed, and “instruction sentence” and “instruction sentence including branch etc.” are described in “instruction sentence and branch unit in the inside”. An internal instruction branch sequence number is added, and the program internal instructions For each serial number, a coverage passing function is generated in a format that can be interpreted by the compiler, added to the coverage test ready program file 203 as a part of the program, and existing completion or stored in the coverage test ready program file 203 As a result of analysis for the semi-completed program, the program includes a program that realizes a function of storing an instruction branch serial number and a C0 target C1 target classification symbol in a coverage information accumulation file 206 described later as an explanation of FIG. Here, 202 is referred to as an analysis recording program.
[0009]
Reference numeral 207 denotes an object module generation procedure. Here, the object module 208 is generated using a compiler with reference to the coverage test ready program file 203. Since a method for generating an object module using a compiler is well known to those skilled in the art, a description thereof will be omitted to avoid complication, but here it is referred to as a compilation process.
[0010]
Reference numeral 209 denotes a test execution procedure. This is a procedure for executing the object module 208 by linking the generated object module 208 with the environment corresponding to the test case. Since it is considered easy for those skilled in the art to create an environment corresponding to a test case, a description thereof is omitted here.
[0011]
209 is a coverage passing function described later as the description of FIG. 7 by executing the coverage passing function described later as the description of FIG. 7 and the description added to the coverage test ready program file 203 as described above and FIG. The above-described and later-described test case symbols, the above-described and later-described C0 target C1-target classification symbols, and the execution result of the coverage passing function are associated and recorded in the coverage information accumulation file 206 in correspondence with the instruction branch sequence numbers described later. . Here, 209 is referred to as a coverage data acquisition process.
[0012]
FIG. 3 is a diagram showing a test target program storage file that is a file for storing the source program 201, 301 is a test target program storage file, and 302 is an existing completed or test target indicated as 201 in FIG. A source program that is a semi-finished program is shown.
[0013]
FIG. 4 is a flowchart showing a processing procedure for carrying out 202 of FIG. 2 and will be described below.
[0014]
Reference numeral 401 denotes processing for copying the source program 201 stored in the test target program storage file and storing it in the coverage test ready program file 203. This processing method is obvious to those skilled in the art. This process is called a command sentence copy process.
[0015]
402, an existing completed or semi-completed program stored in the coverage test ready program file 203 is extracted in units of command statements, and “command statement” and “command statement including branch etc.” are “command statement and branch in it” This is a process of adding an instruction branch serial number in a program to an “instruction sentence” unit and an “instruction sentence including a branch or the like, an instruction sentence and a branch unit within the instruction sentence” unit. Here, in advance, all the branch sentence types existing in the language specification are identified and stored, and for the command sentence extracted here, all the branch statements existing in the stored language specification are stored. By identifying according to whether or not they match, in the case of a branch statement, an instruction branch sequence number in the program and the C0 target C1 target classification symbol described above and below will be added, so that “instruction statement” and “instruction including branch etc.” The “sentence” is processed to be analyzed into “an imperative sentence and a unit of branch in the instruction sentence”. The process of adding the serial number to the analysis result is considered to be easily performed by those skilled in the art, and is therefore omitted to avoid complicating the explanation. This process is called an in-program instruction branch serial number addition process.
[0016]
403 is extracted in units of instruction statements in 402 step, and “instruction sentence” and “instruction sentence including branch etc.” to which the instruction branch serial number in the program is added are C0. As data named the target C1 target classification symbol, C0 meaning C0 known to those skilled in the art as C0 coverage is assigned to “command sentence” as data, and “branch unit within the command sentence” is assigned to this “command sentence”. A process of allocating C1 known as C1 coverage to the trader as data and a process of storing in the coverage information accumulation file 206 simultaneously with the above-described in-program instruction branch serial number are performed. In this case, C0C1 data including the meanings of both C0 coverage and C1 coverage is assigned to the unit of one command statement and one command statement that can branch, and the branch unit. It is considered that a program for realizing this processing can be easily created by those skilled in the art if only this description is read. Therefore, a detailed description of the creation method is omitted to avoid complication. The process 403 is called C0 object C1 object classification symbol storage process.
[0017]
404 is a program that is added to the existing completed or semi-completed program stored in the coverage test ready program file 203 to “instruction sentence” and “an instruction sentence including a branch etc. is an instruction sentence and a unit of branch in the instruction sentence”. Corresponding to the internal instruction branch serial number, “the internal instruction branch serial number information in the program is stored internally, and the above-mentioned coverage information accumulation file 206 is referred to the internal internal program branch serial number correspondence at the time of execution. This is a process of generating and appending a coverage passing function that has a function of recording a single symbol called a symbol and exists in a format that can be interpreted by the above-described compiler or the like. If the specifications described here are presented, it is considered that those skilled in the art can easily program the coverage passing function. 404 is referred to as a coverage passing function additional recording process.
[0018]
405 determines whether there is a statement that has not completed all 401, 402, 403, 404 for the existing completed or semi-completed program stored in the coverage test ready program file 203. If not, exit; otherwise
It repeats processing from. Reference numeral 405 is referred to as a statement analysis completion determination process.
[0019]
FIG. 5 shows the structure of the coverage information accumulation file 206 of this embodiment. The coverage information storage file 505 is composed of four items: an instruction branch sequence number 501, a test case symbol 502, a C0 target C1 target classification symbol 503, and a coverage passing symbol 504.
[0020]
In the instruction branch sequence number 501 in the program, “instruction sentence” unit or “instruction sentence including a branch” in the existing completed or semi-completed program stored in the coverage test ready program file 203 is “instruction sentence and its internal part”. Stores the in-program instruction branch sequence number added to the “branch unit in”.
[0021]
The test case symbol 502 is known as a test case by those skilled in the art in order to test the source program 201, and stores the symbol name of the test case necessary for executing the object module 208. Here, since the method of inputting a test case correspondence symbol for one test case is not directly related to the description of the claims, the description is omitted.
[0022]
The C0 target C1 target classification symbol storage field 503 stores the C0 target C1 target classification symbol.
[0023]
In the coverage passage symbol storage field 504, the coverage passage function embedded in the coverage test ready program file 203 is used for entering the above-described coverage passage symbol when the test is executed.
[0024]
FIG. 6 is a diagram showing a test case file. Reference numeral 601 records the overall configuration, 602 records the test case symbols described above, and 603 records test case management comments. A method for creating a file or the like to be created for a test case during a program execution test is obvious to those skilled in the art, and is omitted here to avoid complications.
[0025]
FIG. 7 shows an example of a source program stored in the test target program storage file.
[0026]
FIG. 8 shows an example of a portion corresponding to FIG. 7 of the coverage test ready program file that is copied from the source program stored in the test target program storage file including the example of FIG. 7 and stored together with the coverage passing function. The shaded portion indicates the coverage passing function. The coverage passing function corresponds to the instruction branch sequence number in the program. “The instruction branch sequence number information in the program is stored internally, and the above-mentioned coverage information storage file 206 is referred to the internal program instruction branch sequence number at the time of execution. It has a function of recording one symbol called a coverage passing symbol and exists in a format that can be interpreted by the above-mentioned compiler or the like.
[0027]
FIG. 9 is an example of the coverage information accumulation file 206 generated as a result of executing the analysis recording program indicated by 202 with respect to the example of the source program stored in the test target program storage file shown in FIG. Here, data 1, 2, 3, 4, 5, 6, and 7 are generated for the instruction branch sequence number in the 1101 program, and data 2, 2, 2, 2, 2, 2, and 2 are pre-assigned for the 1102 test case symbol. Stored in As described above, the analysis record program stores the C0 target C1 target classification symbols 1103 as C0, C1, and C0C1 for the instruction branch sequence numbers in the program. No data is input to the coverage passing symbol 1104 when the analysis recording program is executed.
[0028]
FIG. 10 is an example of the information accumulation file 206 as a result of executing the coverage data acquisition process indicated by 209.
[0029]
In FIG. 10, the execution result of the test indicated by 209 is recorded. In addition to 1201 in-program instruction branch serial number, 1202 test case symbol, 1203 C0 target C1 target classification symbol data, 1204 coverage passing symbol is also stored.
[0030]
Here, C0 test coverage is defined as a percentage in which the numerator is the number of test executed instructions and the denominator is the total number of instructions, and the calculation of C1 test coverage is the number of test executed branches and the denominator is the total number of branches. It is defined by percentage. Accordingly, it is obvious to those skilled in the art that the C0 test coverage and the C1 test coverage can be easily calculated from the elements shown in FIG. For this reason, the description regarding the calculation and display method for deriving the C0 test coverage and the C1 test coverage from FIG. 10 is omitted to avoid complexity.
[0031]
As described above, (1) means such as a file for storing an existing completed or semi-completed program composed of a declaration statement, a command statement, a comment, etc. corresponding to one compiler specification (herein called a test target program storage file) And (2) means such as a file to copy and store the contents of the test target program storage file (herein called the coverage test ready program file), and (3) the existing completion stored in the coverage test ready program file Or, the semi-completed program is analyzed into “instruction sentence” and “instruction sentence including branch” as “instruction sentence and branch unit in the inside”, and the “instruction sentence” and “instruction sentence including branch” are A unique identification symbol in the program (herein referred to as an instruction branch serial number in the program) Is stored in the coverage information storage file together with a symbol indicating the result of classification such as an instruction or an instruction internal branch (herein referred to as C0 target C1 target classification symbol) (herein referred to as a source analysis function) and the coverage test. A means for generating a coverage passing function in a format that can be interpreted by the compiler described in (5) below for each instruction branch sequence number in the program in the ready program file and embedding it as a part of the program (here called the source analysis / embedding program) And (4) means such as a file (herein referred to as a coverage information storage file) for recording the C0 target C1 target classification symbol and the execution result of the following coverage passing function in association with the instruction branch serial number in the program. (5) exists in a format that can be interpreted by the compiler, etc. A function that stores a symbol (here called the coverage passing symbol) in the coverage information storage file when it is generated and executed uniquely for each serial number is realized (here called the coverage passing function). is doing.
[0032]
According to the present embodiment, according to (1), (2) and (3), in the coverage information accumulation file, together with the instruction branch serial number in the program and the C0 target C1 target classification symbol (herein called the source analysis function) Thus, it is possible to automatically cover and extract test coverage objects. In addition, in (1), (2), (3), (4), and (5), in the test debugging of the system development work, the test execution status check of the target program is manually performed to obtain C0 coverage and C1 coverage. Instead, it is possible to improve the productivity of program development by reducing the number of man-hours for test debugging by mechanically executing it with a compiler or the like.
[0033]
In addition, it is possible to determine whether the test case is good or bad by managing the coverage passing symbols for each test case symbol.
[0034]
【The invention's effect】
According to the present invention, software debugging can be supported more easily.
[Brief description of the drawings]
[Fig. 1] Device configuration diagram of this embodiment [Fig. 2] Overview diagram of this embodiment [Fig. 3] Test target program storage file of this embodiment [Fig. 4] Analysis recording program of this embodiment [Fig. Coverage information accumulation file of embodiment [FIG. 6] Test case file [FIG. 7] Example of test target program of this embodiment [FIG. 8] Example of coverage test program file of this embodiment [FIG. 9] Coverage of this embodiment An example of an information storage file (after executing the analysis recording program)
FIG. 10 is an example of a missing number of coverage information accumulation file according to the present embodiment (after performing coverage data acquisition processing).
[Explanation of symbols]
101 CPU
102 Memory 103 External Storage Device 104 Input Device 105 Display Device 106 Printer 201 Source Program 202 Analysis Recording Program 203 Coverage Test Ready Program Storage File 206 Coverage Information Accumulation File 207 Compile Processing 208 Object Module 209 Coverage Data Acquisition Processing 301 Test Target Program Storage File 302 Source program 401 Instruction copy processing 402 In-program instruction branch sequence number addition processing 403 C0 target C1 target classification symbol storage processing 404 Coverage passing function additional processing 405 Command sentence analysis completion determination processing 501 In-program instruction branch sequence number 502 Test case symbol 503 C0 target C1 target classification symbol 504 Coverage passage symbol 505 Coverage information storage file 601 Stroke file 602 Test case symbol 603 Test case management comment 1101 In-program instruction branch sequence number 1102 Test case symbol 1103 C0 target C1 target classification symbol 1104 Coverage passing symbol 1201 In-program instruction branch sequence number 1202 Test case symbol 1203 C0 target C1 Target classification symbol 1204 Coverage passage symbol

Claims (2)

A test target program storage file for storing an existing completed or semi-completed program including at least a declaration statement, a command statement, and a comment corresponding to one compiler specification;
A coverage test ready program file for copying and storing the contents of the test target program storage file;
For each instruction sentence included in an existing completed or semi-completed program stored in the coverage test ready program file, and in the case where the instruction sentence includes an instruction internal branch, the instruction sentence unit and in the instruction inside the branch unit, and means for adding program within the instruction branches sequence number is a unique identification symbol within the existing finished or semi-finished program,
The coverage information storage file, by storing in association with the program within the instruction branches sequence number C0 object C1 target classification symbol identifying the statement or the instruction inner branch, said about the contents of the test program storage file Means for realizing storage in the coverage information accumulation file together with storage in the coverage test ready program file ;
In the coverage test ready program file, a coverage passing function is generated in a format that can be interpreted by the compiler for each instruction branch serial number in the program, and the coverage passing function is converted into the existing completed or semi-completed program. Or means for storing a source analysis / embedding program that is embedded as a part of a semi-finished program and exists in a format that can be interpreted by a compiler;
A coverage passing function that is uniquely generated for each instruction branch sequence number in the program by the source analysis / embedding program, and is a symbol indicating that the source analysis / embedding program has been executed. Means for calculating a coverage passing function to be stored in the information accumulation file,
In the coverage information accumulation file, the C0 target C1 target classification symbol and the execution result of the coverage passing function are recorded in association with the instruction branch sequence number in the program in the source analysis / embedding program. Test debug device. In the program test debugging apparatus according to claim 1 ,
A means for storing in advance all types of branch statements that are imperative statements including branches existing in the language specification of the existing completed or semi-completed program,
The means for dividing compares whether the instruction statement divided matches the type of the stored branch statement, and whether the instruction statement includes a branch depending on whether the comparison matches. A program test debugging apparatus characterized by determining

Images