JP2000305812A - System for editing retest procedure, system applying retest procedure editing system, and computer-readable recording medium recording retest procedure editing program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To generate a retest procedure of high quality by editing an old test procedure according to the contents of differences obtained by comparing an old program with a corrected program and outputting the retest procedure corresponding to the corrected program. SOLUTION: The source programs are inputted from the old program 120 and corrected program 110, different places (deletion, modification, addition, etc.), of the two source programs are analyzed, and the analysis result is outputted to program correction contents 350. Relating to a test procedure correction part 320, the analysis result stored in the program correction contents 350 and the test procedure of the old test procedure 220 are imputted respectively and the contents of the both are collated and analyzed to correct the old test procedure 220 corresponding to the old program corresponding to the correction contents of the corrected program 110, and the corrected procedure is outputted to a retest procedure 210. Consequently, the quality of the retest procedure is secured, the editing of the existent test procedure is speeded up, and the burden on a test operator is lightened.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to modification of a program, porting of a program to another system, or application / level-up of a compiler / assembler / interpreter used for translating a program. The present invention relates to a retest procedure editing method relating to a test procedure used for a program test when a retest procedure is executed, a system to which the retest procedure editing method is applied, and a computer-readable recording medium recording a retest procedure editing program.

[0002]

2. Description of the Related Art In software development, program testing plays an important role in ensuring the quality of a program.

[0003] After a program test is performed at least once, in order to correct a detected bug or add a function, in a test of a modified program in which the program is modified, a test procedure (for example, a series of procedures) of a program related to a modified portion is performed. Maintenance of debug commands or scripts) was manual. The maintenance of this test procedure is carried out by maintaining the test procedure performed in the past so as to be suitable for retesting the modified program in order to confirm that there is no unexpected malfunction due to the modification made to the program. Was implemented. However, in recent years, software systems have become huge and complicated, and a lot of trouble and time have been required due to the review work of the test procedures, and it has become difficult to reuse past test procedures. ing.

Therefore, there is a demand for more efficient program testing by reusing past test procedures in software development.

[0005] The terms used here and their meanings are as follows.

[0006] 1) The program test means a test of the program executed to confirm the validity of the logic / algorithm or the interface of the program.

[0007] 2) The retest means a program test performed when a program under test is modified (including a source program modification or a patch).

[0008] 3) The test procedure is a procedure that stores information for instructing execution control of a load module to be subjected to a program test, confirmation of program contents, printing, and the like. For example, a debug command used for performing a test corresponds to this.

4) The old program indicates a program (for example, a source program) before correction is stored. It is assumed that the old program has already been subjected to the program test.

[0010] 5) The modified program is a program in which a program stored in the old program is modified in some way.

6) The test system refers to a system that executes a program under test in accordance with instructions such as execution control stored in a test procedure.

7) The test result means that the program under test is executed in accordance with an instruction (for example, a debug command or the like) such as an execution control stored in the test procedure, and the value of a variable at the time of execution is controlled by the execution control or the like. Refers to information output by instructions.

FIG. 1 is a diagram for explaining an example of the configuration of a conventional program test system.

In the figure, 110 is a correction program, 120 is an old program, 220 is an old test procedure, 210 is a retest procedure, 150 is a compiler / linker, 500 is a load module, 400 is an object, 600 is a test system, and 700 is a test system. It is a test result. An example of a conventional procedure for obtaining a retest result in the retest will be described with reference to FIG. The retest operator instructs the compiler (compiler / linker) 150 to translate the source program stored in the correction program 110. Then, the output of the translation and the object module (OM) 400 are combined by the linker (compiler / linker) 150, and the load module (execution module) of the program under test is output to the load module (LM) 500.

The re-test operator detects a correction portion while comparing the source program of the correction program 110 with the source program of the old program 120, and corrects the old test procedure 220 based on the correction portion to execute the test of the load module. Maintain a suitable retest procedure 210.

The retest operator then uses the retest procedure 210 to load the load module into the load module 50.
Test system 60 to load and run from zero
Instruct 0. The test system 600 controls the execution of the load module (program under test) in accordance with the described instruction (for example, a debug command) of the retest procedure 210 and compares the test result (execution result) with the test result 7.
Output to 00.

As described above, in the prior art, the contents of the correction (difference) of the source program before and after the correction are manually investigated and examined, and the old test procedure corresponding to the source program before the correction is replaced with the source program after the correction. The revised test procedure was created to correspond to the above, and the retest was performed according to the retest procedure.

As a technique related to the present invention, Japanese Patent Application Laid-Open
There is 8-272648 publication. This publication discloses a technique for automatically editing a breakpoint designated by an embedded debug command of a source program of a program under test when the source program is modified, so that the breakpoint is suitable for a retest.

[0019]

In the above prior art,
There are the following issues.

(1) Unless the logic / algorithm and interface of the source program are known, it is difficult to create a retest procedure by reusing the old test procedure, and it is also difficult to confirm the validity of the retest procedure. It is.

(2) If the source program of the correction program has a wide range of corrections, it is highly probable that the amount of correction to the old test procedure will increase proportionately. Therefore, confirming the validity of the retest procedure is also complicated and difficult,
It is difficult to ensure the quality of the program under test by testing based on the retest procedure. Therefore, there is a high possibility that a method of creating a test procedure from the beginning is adopted, and the value of reusing the old test procedure tends to decrease in inverse proportion to the amount of correction to the old test procedure.

(3) In Japanese Patent Application Laid-Open No. 8-272648, when a source program of a correction program is corrected, a correction operator must maintain (embed) a test procedure in advance. Further, even when only the test procedure embedded in the source program is changed, work such as compiling and linking occurs, so that the burden on the correction operator is large.

The present invention has been made in view of the above points, and by editing an existing test procedure, the quality of the retest procedure is ensured, the speed of editing the existing test procedure is increased, Re-test procedure editing method to reduce the burden of
An object of the present invention is to provide a system to which a retest procedure editing method is applied and a computer-readable recording medium on which a retest procedure editing program is recorded.

[0024]

The structure of the present invention for solving the above-mentioned problems will be described below.

According to a first aspect of the present invention, there is provided a program correction content extracting section for comparing an old program with a correction program obtained by adding a correction to the old program, and storing a difference content relating to a variable described in both programs; Edit the old test procedure corresponding to the old program based on the difference content,
And a retest procedure editing unit for outputting a retest procedure corresponding to the correction program. The present invention allows for the creation of high quality retest procedures.

According to a second aspect of the present invention, when the modified program is created by deleting a variable from the old program, the re-test procedure in which a test procedure relating to the variable is deleted from the old test procedure is output. This is a re-test procedure editing method. According to the present invention, when a correction for deleting a variable is performed, a test procedure relating to the variable can be efficiently deleted from a retest procedure.

According to a third aspect of the present invention, when the modified program is created by adding a variable from the old program, the retest procedure in which a test procedure relating to the variable is added from the old test procedure is output. This is a re-test procedure editing method. When a modification for adding a variable is performed according to the present invention, a test procedure relating to the variable can be efficiently added to a retest procedure.

According to a fourth aspect of the present invention, when the modified program is created by changing a variable from the old program, the retest procedure in which a test procedure related to the variable is added or changed from the old test procedure. The retest procedure editing method is characterized by outputting When a modification for changing a variable is performed according to the present invention, a test procedure relating to the variable can be efficiently added or changed to a retest procedure.

According to a fifth aspect of the present invention, when the modified program is created by changing the execution unit from the old program, the variable affected by the change is added before or after the change. A retest procedure editing method characterized by outputting the retest procedure to which a test procedure related to the retest procedure is added. According to the present invention, when the execution instruction portion is modified, a test procedure for confirming a value before or after execution of the modified execution instruction can be efficiently added.

According to a sixth aspect of the present invention, in a system to which a retest procedure editing method for testing a correction program according to a retest procedure is applied, an old program is compared with a correction program obtained by modifying the old program. A program correction content extraction unit that stores a difference content regarding variables described in both programs, and an old test procedure corresponding to the old program edited based on the difference content, and a retest procedure corresponding to the correction program is performed. A system to which a retest procedure editing method is applied, comprising: a retest procedure editing unit for outputting; and a test execution unit for controlling execution of an execution module created from the correction program according to the retest procedure. It is. According to the present invention, an old program can be modified to a modified program, and a retest procedure can be efficiently generated from an old test procedure.

According to a seventh aspect of the present invention, when the modified program is created by deleting a variable from the old program, the re-test procedure in which a test procedure relating to the variable is deleted from the old test procedure is output. This is a system to which a retest procedure editing method is applied. According to the present invention, in the modification from the old program to the correction program, when the variable is deleted, the test procedure related to the variable is deleted when the retest procedure is generated from the old test procedure, and the retest of the correction program is performed on the system. It becomes possible to carry out efficiently.

According to the present invention, when the modified program is created by adding a variable from the old program, the re-test procedure in which a test procedure relating to the variable is added from the old test procedure is output. This is a system to which a retest procedure editing method is applied. According to the present invention, in the modification from the old program to the correction program, when a variable is added, a test procedure related to the variable is added when a retest procedure is generated from the old test procedure, and a retest of the correction program is performed on the system. It becomes possible to carry out efficiently.

According to a ninth aspect of the present invention, when the modified program is created by changing a variable from the old program, the retest procedure in which a test procedure related to the variable is added or changed from the old test procedure. This is a system to which a retest procedure editing method characterized by outputting a retest is applied. According to the present invention, in modifying a program from an old program to a modified program, when a variable is changed, a test procedure related to the variable is changed or added when a retest procedure is generated from the old test procedure. Testing can be performed efficiently.

According to a tenth aspect of the present invention, when the modified program is created by changing the execution unit from the old program, the variables affected by the change are
A retest procedure editing method, wherein the retest procedure in which a test procedure for the variable is added before or after the change is output. According to the present invention, in the modification from the old program to the correction program, when an execution instruction is modified, when a re-test procedure is generated from the old test procedure, a test procedure relating to a variable affected as an action of the execution instruction is added, It is possible to efficiently retest the correction program on the system.

[0035] The invention according to claim 11 is a program correction content extracting means for comparing an old program with a correction program obtained by adding a correction to the old program, and storing a difference content relating to a variable described in both programs; Retest procedure editing means for editing the old test procedure corresponding to the old program based on the content of the difference, and outputting a retest procedure corresponding to the correction program; This is a computer-readable recording medium on which a retest procedure editing program for realizing a function of outputting a test procedure is recorded. According to the present invention, it is possible to provide a computer-readable recording medium program recording a retest procedure editing program for generating a high quality retest procedure.

According to a twelfth aspect of the present invention, when the correction program is created by deleting a variable from the old program, the retest procedure in which a test procedure relating to the variable is deleted from the old test procedure is output. This is a computer-readable recording medium on which a retest procedure editing program for realizing the function of performing the above is recorded. According to the present invention, it is possible to provide a computer-readable recording medium recording a retest procedure editing program for efficiently deleting a test procedure related to the variable from the retest procedure when a correction for deleting the variable is performed. .

According to a thirteenth aspect of the present invention, when the modified program is created by adding a variable from the old program, the retest procedure in which a test procedure relating to the variable is added from the old test procedure is output. This is a computer-readable recording medium on which a retest procedure editing program for realizing the function of performing the above is recorded. According to the present invention, it is possible to provide a computer-readable recording medium on which a retest procedure editing program for efficiently adding a test procedure relating to a variable to a retest procedure when a modification for adding a variable is performed. .

In the invention according to claim 14, when the modified program is created by changing a variable from the old program, the retest procedure in which a test procedure related to the variable is added or changed from the old test procedure. Is a computer-readable recording medium on which a retest procedure editing program for realizing the function of outputting a retest is recorded. According to the present invention, it is possible to provide a computer-readable recording medium recording a retest procedure editing program for efficiently changing or adding a test procedure relating to a variable to a retest procedure when a modification for changing a variable is performed. become.

According to a fifteenth aspect of the present invention, when the modified program is created by changing the execution unit from the old program, the variables affected by the change are:
A computer-readable recording medium recording a retest procedure editing program for realizing a function of outputting the retest procedure in which a test procedure relating to the variable is added before or after the change. According to the present invention, a computer-readable recording medium recording a retest procedure editing program for efficiently changing or adding a test procedure relating to a variable affected by a corrected execution instruction to a retest procedure when the execution instruction section is modified Can be provided.

[0040]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Before describing embodiments of the present invention,
A configuration and an operation outline which help understanding of the present invention will be described with reference to FIG. <First Configuration and Operation Outline of the Present Invention> FIG.
FIG. 2 is a diagram for explaining the configuration and operation outline of FIG. 110 is a correction program, 120 is an old program, 220 is an old test procedure, 210 is a retest procedure generation system, 900 is a retest procedure generation system, 300 is a retest procedure editing unit, 310 is a program correction content extraction unit, and 320 is a test procedure. A correction unit 330 is a test procedure addition unit, and 350 is a program correction content.

Old program 120 and correction program 11
From 0, the source program is input, the difference between the two source programs (deletion, change, addition, etc.) is analyzed, and the analysis result is output to the program modification content 350. The test procedure correction unit 320 inputs the analysis result stored in the program correction content 350 and the test procedure of the old test procedure 220, and compares and analyzes both contents to obtain the old test procedure corresponding to the old program. 220
Is corrected according to the correction contents of the correction program 110,
Output to retest procedure 210.

Further, the test procedure adding section 330 inputs the program correction content 350 extracted and output by the program correction content extraction section 310, edits the correction content, and edits a test procedure to be added. Retest procedure 21
Additional output to 0.

Note that the program correction content extraction unit 310
The test procedure correction unit 320 and the test procedure addition unit 330 are programs, and are non-volatile memories such as SRAMs, CD-ROMs, and the like.
It can be stored in a storage medium such as a ROM, a magneto-optical disk, or a magnetic disk and distributed, and further stored in a storage device such as a magnetic disk device of a server connected to a network and connected to the network. According to the request from the client, the three programs (which can be combined with at least one program) can be downloaded and used, or can be distributed.

The above procedure, that is, the difference (deletion, change, addition, etc.) between the source program before and after the correction is analyzed, and the retest procedure 210 is executed from the existing old test procedure based on the information of the difference. Can be edited and output. <Second Configuration and Outline of Operation of the Present Invention> FIG.
FIG. 2 is a diagram for explaining the configuration and operation outline of FIG. 110 is a correction program, 120 is an old program, 220 is an old test procedure, 210 is a retest procedure, 800 is a load module which is an executable program, 600 is a test system, 70
0 is a test result, 900 is a retest procedure generation system, 30
0 is a retest procedure editing unit, 310 is a program correction content extraction unit, 320 is a test procedure correction unit, 330 is a test procedure addition unit, 350 is a program correction content, and 610 is a test execution unit.

The test system 610 shown in the figure executes the load module (LM) 800, which is the program under test, based on the retest procedure 210 generated by the retest procedure generation system 900 (FIG. 2). Step 210
Is controlled according to the following. Then, the execution result of the load module 800 is output to the test result 700.
The retest procedure 210 used at this time is the first test of the present invention.
It is generated based on the configuration and operation of the present invention.

Note that the program correction content extraction unit 310
The test procedure correction unit 320, the test procedure addition unit 330, and the test execution unit 610 are programs, which are stored in a non-volatile memory such as an SRAM or a storage medium such as a CD-ROM, a magneto-optical disk, or a magnetic disk and distributed. Can also be stored in a storage device such as a magnetic disk device of a server connected to a network, and the above-described 3 is provided by a request from a client connected to the network.
It is also possible to download and use two programs (the program modification content extraction unit 310, the test procedure modification unit 320, and the test procedure addition unit 330 can be combined as at least one program), or to distribute them. . <Embodiment of the present invention> An embodiment of the first invention will be described below. This embodiment will be described with reference to a source program described in the C ++ language. It should be apparent to those skilled in the art that the present invention can be easily applied to other languages.

First, an outline of the operation of the present invention is shown in FIGS. 4 and 5, and examples of interfaces according to the embodiment of the present invention are shown in FIGS. 6 to 12. Examples of each interface include an example of creating a basic test procedure (FIG. 6), an example of modifying an old source program into a modified source program (FIG. 7), an example of describing old test contents (FIG. 8), and an example of an old source program. Of the format for storing the analysis result of the difference between the source program and the modified source program created by modifying the source program (FIG. 9), the analysis result of the start line and end line number of the function on the old source program and the modified source program An example of storage of a variable (FIG. 10) of a variable declaration part in a source program (FIG. 11) and an example of modifying an old test content to a retest content (FIG. 12) will be described below. I do. <First Configuration Example of the Present Invention> FIG. 4 is a diagram illustrating an example of the configuration of a retest procedure generation system 900. FIG. 4 is a diagram in which a terminal device 50 is added to FIG.
FIG. In the figure, a terminal device 50 is a terminal device such as a display device connected to the retest procedure content generation system 900, and can input information. The terminal device 50 is connected to a retest procedure content generation system 900 and a LAN (Local Area Network) (not shown).
A terminal device connected via a network such as k) may be used. In this embodiment, the program correction content 350 includes a difference content 410, an execution portion correction content 420, and a variable declaration portion correction content 430. This difference content 410 stores information obtained by analyzing the difference between the source program of the old program 120 and the source program of the correction program 110. The execution part correction contents 420 means language analysis of the source programs of the old program 120 and the correction program 110 (analysis of the source program performed when a compiler or the like translates, for example, analysis of variables and execution logic defined in the source program). ) Is stored. The variable declaration section correction contents 430 stores information on variables obtained by language analysis of the old program 120 and the correction program 110. FO
Variables such as RTRAN that are implicitly declared to the execution unit (for example, implicit declaration of the variable I by I = 0 or the like in FORTRAN) are also handled in the same manner as the variables in the C ++ language described above. <Second Configuration Example of the Present Invention> FIG. 5 is a diagram illustrating a configuration example of a test system 600 to which a retest procedure generation system 900 is applied.

According to the present invention, a test system 600, a load module 800, a test execution unit 610, and a test result 700 are provided in the first embodiment of the present invention. The test execution unit 610 controls the execution of the program under test (load module 800) of the test system according to the retest procedure 210. The test system 600 includes a retest procedure generation system 900, a retest procedure 210, and a test execution unit 610. <First Embodiment of the Present Invention> FIG. 6 is a view for explaining an example of the definition of the program test procedure stored in the test procedure.

In the figure, four debug commands are described. The first line is a break command. This br
The eak command is the next debug command during execution of the specified program (load module) before executing the instruction described in the line number on the source program.
Execute the print command (second line). This print command prints the current value of the variable name described in the source program. Then, the step command on the third line is executed. This step command executes the next one instruction (one step) on the source program. Then, the cont command (the fourth line), which is the next debug command, is executed. That is, the cont command is an instruction to execute instructions on the source program continuously. Of course, when the vehicle again passes the break point specified by the break command on the first line, the debug commands on the second to fourth lines are executed.

FIG. 7 is a diagram for explaining an example in which the modification program 110 is created by adding a change to the old program 120. In the figure, addition 1 indicates that "int b1;" has been added to line number 101 of the old program.

Addition 2 indicates that "b1 = al * 3;" has been added to line number 103 in the old program.

The deletion 3 corresponds to line numbers 200 to 200 of the old program.
Indicates that 297 has been deleted. Therefore, these deleted line numbers do not appear in the correction program 110.

Change 4 indicates that "// comment" described in line number 301 of the old program has been changed to "int b3;" described in line number 201 of the modified program.

The deletion 5 indicates that the information “a3 = 0;” described in the line number 302 of the old program is deleted. This deleted line does not appear in the patch.

Addition 6 is the line number 207 of the correction program.
"B3 = data1 * 10;" has been added.

The change 7 is the line number 411 of the old program 120.
"Printf (" b4 =% d \ n ", b4);" described in "this-> Method1 (b
4); ".

FIG. 8 is a diagram for explaining an example of the old test procedure 220 composed of the old test procedures 221 to 224. These old test procedures 220 correspond to the old test procedure 22 shown in FIG.
This is an example composed of four old test procedures based on the definition example of 0.

FIG. 9 is a view for explaining an example of the storage format of the difference contents 410 stored in the program correction contents 350. In the figure, the old program 120 and the correction program 110
7 (for example, additions 1 to
An example of a table format in which the analysis result of the change 7) is stored in the difference content 410 is shown. In the start line column and the end line column of the old program column indicated by addition 1, addition 2 and addition 6 in FIG. 7, a portion where a horizontal line is described indicates that there is no target to be added / deleted / changed. And binary zero (null value) is set. The contents stored in the difference contents 410 for each of addition 1 to change 7 (FIG. 7) will be described.

In the line of addition 1 (FIG. 7), the old program 1
Since there is no deletion / change to the file 20, the above-mentioned binary zero is set in the start line and the end line of the old program column (FIG. 9), while the corresponding correction program column (FIG. 9).
In the start line and end line fields, 101 is set as both numbers. Since the number of additional lines is one, 1 is set in the corresponding additional line number column, and “add” is set in the corresponding addition / deletion / change column.

In the second added line, since there is no deletion or change to the old program 120, the above-mentioned binary zero is set in the start line and the end line column, while the start line and the corresponding line are set in the corresponding modified program column. 103 is set as a number in the end row column. Since the number of the additional lines is one, 1 is set in the corresponding additional line number column, and the character string “add” is set in the corresponding addition / deletion / change column.

In the line of delete 3, regarding the deletion of the old program 120, 200 is displayed in the start line column and 200 is displayed in the end line column.
297 is set, while the above-mentioned binary zero is set in the start line and end line fields of the corresponding modification program.
Since the number of deleted lines is 98, -98 (minus 98) is set in the corresponding additional line number column, and the character string "delete" is set in the corresponding addition / deletion / change column.

In the line of change 4, regarding the change to the old program 120, 301 is set in the start line column and 301 in the end line column of the old program column, while 201 is set in the start line and end line column of the modified program column. Is set. There is no increase or decrease in the number of lines associated with this change, so 0
Is set, and “change” is set in the add / delete / change column.

In line 5 for deletion, regarding the deletion of the old program, 302 is set in the start line column and 302 in the end line column of the old program column, while binary zero is set in the start line and end line columns in the correction program column. Is set. Since the number of deleted lines is one, the number of additional lines is set to −1 (minus one), and the character string “delete” is set in the add / delete / change column.

In the sixth line, since the old program 120 is not deleted / changed, the above-mentioned binary zero is set in the start line and the end line of the old program column, while the start line and the second line are set in the modified program column. In the end line column, 207 is set as a line number. Since the number of additional lines is one, 1 is set in the number of additional lines column, and the character string “add” is set in the addition / deletion / change column.

In the line of the change 7, regarding the change to the old program 120, 411 is set in the start line column of the old program column, and 309 is set in the start line and end line column of the corresponding modified program column. You.
Since the number of rows does not increase or decrease with this change, 0 is set in the corresponding number of additional rows, and “change” is set in the corresponding add / delete / change column.

FIG. 10 is a view for explaining an example of the storage format of the execution section correction contents 420 stored in the program correction contents 350.

In the figure, function names added, changed, or deleted in the old program 120 or the modified program 110 are set. The start line number of the function name described in the old program 120 is set in the start line column of the old program column, and the end line number of the function is set in the corresponding end line column. The start line number of the function described in the correction program 110 is set in the start line column of the correction program column, and the end line number of the function is set in the end line column.

In the line where the function name is Sample :: Method1, Meth
This indicates that od1 is described in line numbers 100 to 111 of the old program 120, and is described in line numbers 100 to 113 in the modified program 110 after modification. In the function name of Sample :: Method2, since Method2 is deleted from the old program 120, the above-mentioned binary zero is set in the start line and the end column of the modification program column because the line numbers related to this function are not set. . Note that the line numbers are also set for the function names of Sample :: Method3 to Sample :: Method4 as in Sample :: Method1.

FIG. 11 shows an example of the storage format of the variable declaration section correction contents 430.

In the figure, the variable names defined in the old program 120 and the modification program 110 are set in the variable name column. In the variable type column, the type (for example, character, integer, floating point, etc.) of the variable name defined in the old program 120 and the modification program 110 is set. In the addition / deletion / non-change column, any one of addition, deletion, and no change is set for each variable name by modification from the old program 120 to the modification program 110. The old program 12 or the modified program column in the variable definition location column contains the old program 12
0 or the line number of the variable name defined in the correction program 110 is set. The line number of the variable name used in the old program 120 or the modification program 110 is set in the old program column or the modification program column of the variable use location column. In the old program column or the modified program column of the variable effective range column, the valid range of the variable described in the old program 120 or the modified program 110 is set as a start line or an end line.

A specific description will be given by taking data1 as an example of a variable name.

Since the variable name is data1, data1
Is set. Since the type of data1 described on the source program of the old program 110 or the modified program 120 is an integer, int is set in the variable type column. Also, data
1 is not changed when the old program 120 is corrected to the correction program 110, so that the non-change is set to non-change in the add / delete / non-change column.

Data1 is defined as a variable in line number 3 of the old program 120,
Therefore, the line number 3 is set in each of the old program column and the modified program column of the variable definition location column.

Since data1 is used as a variable in the line number 101 of the old program 120 and is also used in the line number 102 of the correction program 110, the line number 101 and the line number 101 are used in the old program column and the correction program column of the variable use location column, respectively. 102 is set. data1 is a variable whose effective range is the line number 100 of the old program 120
To 420, and the range of line numbers 100 to 320 of the modification program 110. Therefore, 100 and 420 are respectively set in the start line and the end line column of the old program column, 100 and 420 are set in the start line and the end line column of the old program column, respectively, and the start line and the end line column of the correction program column are set. Are set to 100 and 320, respectively.

FIG. 12 shows an example in which the old test procedure is modified to the retest procedure with the modification from the old program to the modified program.

In the figure, the old test procedure 220 is the same test procedure as the old test procedure (FIG. 8). As the old program 120 is updated to the correction program 110, the old test procedure 220
Also needs to be updated in accordance with the updated contents to create the retest procedure 210.

First, in the change 21, since the line number of the designated break point was changed from 101 to 102, break Sample.cc:101 of the old test procedure 221 was changed to break Sampl.
This is an example of changing to e.cc:102 and reusing the old test procedure 221 as the retest procedure 211.

The deletion 31 corresponds to 201 of the old program 120.
In this example, the old test procedure 222 is deleted from the retest procedure 210 by deleting the line.

The deletion 51 is an example in which the old test procedure 222 is deleted from the retest procedure 210 by deleting the variable b2 from the old program 120.

In the change 41, since the line number of the designated break point was changed from 302 to 202, the old test procedure 2
This is an example in which 24 break Sample.cc:302 is changed to break Sample.cc:202 and the retest procedure 212 is modified.

In the addition 61, since the variable b3 is added to the correction program 110, the corresponding retest procedure 210
Is a modification to add the retest procedure 213 to the above.

In the addition 71, the "th"
is-> Method1 (b4) ", and as a result, the change in the value of b4 may be important as a key for debugging. Therefore, just before executing the line number 311 (FIG. 7), a command for setting a break point is added to the line number 310 to confirm the value of b4, a comma for outputting the value of b4 is added, and , Each command to continue processing (break, print, cont command)
4 (FIG. 12).

In addition 72, in order to confirm a change in the value of b4 after executing the line number 311, a command for setting a breakpoint is added to the line number 312, and a command for outputting the value of b4 is added. Each command to continue processing (b
reak, print, cont commands) as a retest procedure 215 (FIG. 12).

As described above, when the execution instruction of the corrected line number is added / changed, the debug command for confirming the values immediately before / after the execution of the variables affected by the execution of the instruction is retested. Add to procedure.

The above is the description of each interface.

Next, the processing flow of the test procedure correction unit 320 and the program correction content extraction unit 310 will be described with reference to FIGS.

"Step Snnm" used in the following description
For example, in step 131, nn indicates FIG. 13, and m indicates 1 which is an additional number as a hexadecimal number (1 to 9, A to F).

First, FIG. 13 shows the retest procedure generation system 9.
It is a figure explaining the processing outline flow of 00.

Step S131 is a first step of processing by the program correction content extracting unit 310, in which the source programs of the old program 120 and the correction program 110 are respectively input, and the character strings are compared to analyze the difference. The result is output to the difference content 410 (FIG. 9).

Step S132 is a second step of performing the processing of the program correction content extraction unit 310.
Each of the source programs (FIG. 7) described in + language is input, and information on variables (for example,
The variable name, the type of the variable, the line number where the variable is defined, the reference location of the variable, the start / end line number where the variable is valid, and the like are output to the variable declaration section correction contents 430. In FIG. 11, when a value exists in the old program column of the variable setting location column and no value exists in the correction program column of the corresponding variable usage location column, “delete” is displayed in the corresponding addition / deletion / non-change column.
Set. If the value does not exist in the old program column of the variable setting location column and the value exists in the corresponding correction program column, “addition” is set in the variable declaration section correction content 430 in the addition / deletion / non-change column. If a value exists in the old program column of the variable setting section column and a value exists in the corresponding correction program column, "unchanged" is set in the variable declaration section correction content 430 in the addition / deletion / non-change column. For the storage format of the variable declaration section correction contents 430, refer to FIG. 11 already described.

Step S133 is a step for performing the processing of the program correction content extraction unit 310. The source program (FIG. 7) described in, for example, the C ++ language is input from the old program 120 and the correction program 110, and the function is performed by language analysis. (For example, a function name, a start line / end line number where a function is described) is output to the execution unit correction contents 420. Execution part correction contents 4
For the storage format of 20, refer to FIG. 10 already described.

In step S134, the program correction contents 350 (difference contents 410, execution unit correction contents 42) in FIG.
0, which is composed of the variable declaration section correction contents 430), the notification is sequentially sent to the test procedure correction section 320 and the test procedure addition section 330 when the output of the information extracted is completed. Although not shown in FIG. 13, the notified test procedure correction unit 320 inputs the analysis result of the program correction content 350 and the test content of the old test procedure 220, and analyzes both contents to obtain the old test procedure. The test procedure 220 is corrected (deleted / changed) according to the correction contents of the correction program 110 and output as a retest procedure 210. Then, the called test procedure adding section 330 inputs the program correction content 350 extracted by the program correction content extraction section 310, edits the correction content, edits a retest procedure to be added, and Output to test procedure 210.
Then, the process returns to step S134 of the calling source, and the process ends.

FIGS. 14 to 16 are diagrams for explaining the processing flows (1) to (3) of the test procedure correcting section 320 described above. These processing flows mainly describe the processing of a breakpoint. Therefore, it is necessary to execute this processing flow for the number of breakpoints detected.

First, in step S141 of FIG. 14, the old test procedure 220 (for example, the old test procedures 221 to 22 in FIG. 12) is executed.
4), the information about the breakpoint specified by the break command is extracted.

In step S142, the extracted breakpoint setting information corresponds to the location deleted on the correction program 110 (for example, the lines corresponding to the deletion 3 and the deletion 5 in FIG. Since the breakpoint of the test procedure 222 is not included between the line numbers indicated by the values in the row column, the corresponding test procedure is deleted), and the process proceeds to step S143. Program 1
The position of the breakpoint on 10 is calculated.

In step S145. The break point position of the relevant retest procedure is replaced with the calculated position information and corrected. (For example, as an example of the correction, FIG. 12
Change 41 of break Sample.cc:302 to break Sample.c
The example of amending to c: 202 corresponds to this amendment. ) And
The process ends.

In step S143, the corresponding test procedure is deleted from the retest procedure. (For example, the process of not outputting the old test procedure 222 of FIG. 12 to the retest procedure 210, that is, the process of deleting the old test procedure 222 from the retest procedure 210 is the process of this step.) Then, the process is ended. .

FIG. 1 shows a modification of the embodiment shown in FIG.
It is shown in FIG.

In the figure, in step S151, break point information of the break command described in the old test procedure 220 (for example, see each break command of the old test procedure 220 in FIG. 12) is extracted.

In step S152, the extracted breakpoint information corresponds to the position (line number) deleted on the correction program 110 (for example, the start line of the correction program 110 in the lines corresponding to the deletion 3 and the deletion 5 in FIG. 9). The test procedure is deleted because no breakpoint of the test procedure 222 is included between the column and the end row column.) If the test procedure is deleted, the process proceeds to step 153; otherwise, the process ends.

In step S153, a breakpoint position on the correction program 110 is calculated. In step S154, if the location immediately before or immediately after the deleted portion is within the effective range, the process proceeds to step S155, otherwise, the process ends.

In step S155, the corresponding retest procedure 210 is corrected by replacing the breakpoint position with the calculated position information.

FIG. 16 shows an embodiment obtained by modifying FIG.

In step S161, "delete" set in the addition / deletion / non-change column of the variable declaration section correction contents 430 (FIG. 11) is searched, and the variable set in that line (for example, FIG. 11). The variables a2 and b2) are extracted.

In step S162, the old test procedure 220
An old test procedure in which the variable names of the test procedures 221 to 224 included in FIG. 12 match the variable names extracted in step S161 is extracted.

In step S163, the old test procedure 2
The test procedure that matches the test procedure included in 20 is deleted. That is, from the old test procedure manual 220 to the retest procedure 21
When the correction is performed while copying 0, a process of not outputting the matched test procedure to the retest procedure 210 is performed. Then, the present process ends.

FIG. 17 shows a test procedure adding section 330 (FIG. 2).
It is a figure explaining the processing flow of. This process is called from step S134 in FIG.
This shows a procedure executed as 0. A procedure for editing (adding) the old test procedure 210 corresponding to the added variable when modifying the old program 120 and outputting the modified program 110 will be described.

In step S171, a character string of "addition" is searched from the addition / deletion / non-change column of the variable declaration section correction contents 430. For example, in FIG. 11, b3 corresponds to the added variable.

In step S172, step S1 is executed.
The variable (eg, b3) extracted at 72 is retested 210
Add to Then, the present process ends.

FIG. 18 is a diagram for explaining a modification of the embodiment shown in FIG.

First, in step S181, the difference content 4
For example, 101 to 101, 103 to 103, and 207 to 207 from the start line and end line columns of the modification program column in which “addition” is set in the addition / deletion / change column 10 (FIG. 9).
Extract the line numbers of

In step S182, execution part correction contents 4
From 20 (FIG. 10), the execution location is specified based on the start line number and end line number. In the above example, line number 101
Breakpoint is Sample :: Method1, line number 1
The breakpoint for 03 is Sample :: Method1 and the breakpoint for line number 207 is Sample :: Method2
It turns out that it is.

In step S183, a valid variable is extracted from the variable declaration section correction contents 430 (FIG. 11). That is, the only variable added is b3, and the corresponding line number is 207, so the breakpoint is Sample :: Method
It turns out that it is 2.

In step S184, step S182
Instruction to instruct a break immediately before executing the execution instruction whose execution location is specified from the correction location specified in (for example, brea
k command) and output it to the retest procedure. next,
The variables extracted in step 183 (eg, data1 and
b4) A process for extracting information is performed, and an instruction (for example, a print command or the like) for instructing output of the contents of the variable is generated and output. Further, after executing the execution instruction of the corrected portion, the instruction (for example, break command) for instructing a break is generated and output. Next, an instruction (for example, a print command) for instructing output of the contents of the variable is extracted. Finally, it generates and outputs an instruction to continue processing (for example, a cont command).

FIGS. 19 to 32 are diagrams for explaining the processing flow of the program correction content extraction unit 310.

It is clear that those skilled in the art can easily implement the present invention based on the above description, but the processing flow of the program correction content extraction unit 310 is a supplementary material for further understanding. Is disclosed below.

In step S191, the variable OL
Declares D, NEW, CLASS_NAME, CNT1. OLD is a variable for setting the line number of the old program, NEW is a variable for setting the line number of the correction program,
CLASS_NAME is a variable for setting the class name, CN
T1 is a variable used as a counter.

In step S192, OLD and NEW
Is set to 0 (zero).

In step S193, the old program 12
It is determined whether or not the line number indicated by the OLD and NEW values in 0 and the correction program 110 is the last line. O
If the values of LD and NEW are not both the last row, 1 is added to OLD and NEW respectively in step S194, and the flow branches to step S211.

In step S195, 0 (zero) is substituted for OLD.

In step S196, it is determined whether the line number of the old program 120 indicated by the value of OLD is the last line. If the value of OLD is not the last line, step S1
As 97, 1 is added to OLD, -1 is set to CNT1, and the flow branches to step S241.

In step S198, 0 (zero) is substituted for NEW.

In step S199, if the line number of the modification program 110 indicated by the value of NEW is the last line, the flow branches to step S201; otherwise, the flow proceeds to step S19A.
Is added to NEW, and -1 is set to CNT.
Then, the process branches to step S251.

In step S201, 0 is set to OLD, and-
1 to CNT1 and null character (binary zero) to CLAS
Set to S_NAME.

In the step S202, it is determined whether or not the line number of the old program indicated by the OLD value is the last line. If the value of OLD does not indicate the last line, 1 is added to OLD as step S203, and step S261 is performed.
Branch to

In step S204, 0 is set to NEW, and-
1 to CNT1 and null character (binary zero) to CLAS
Set to S_NAME.

In the step S205, it is determined whether or not the line number of the correction program 110 indicated by the value of NEW is the last line. If it is not the last line, 1 is added to NEW in step S206, and the flow branches to step S291.

In step S207, the completion of the processing of the program correction content extraction unit 310 is notified to the test procedure correction unit 320 and the test procedure addition unit 330, and the processing is completed.

Step S211 in FIG. 21 (step S1
In step S94, it is determined whether the character string of the line number of the old program indicated by the value of OLD matches the character string of the line number of the modified program indicated by the value of NEW.
If they match, the process branches to step S193; otherwise, 0 (zero) is set in CNT1 as step S212.

In step S213, 1 is added to CNT1.

In step S214, the character string existing in the line number of the old program 120 indicated by the value of OLD and NEW
Correction program 1 indicated by the value obtained by adding the value of CNT1 to the value of
It is determined whether or not the character string existing in the line number of 10 matches. If they do not match, step S21 "
The values of NEW and CNT1 are summed, and it is determined whether the value is the last line of the modification program 110. If it is not the last line, the flow branches to step S213, and if so, the flow branches to step S221.

In the step S216, the difference content 410
The following data (1) to (6) are added to (FIG. 9).

(1) Null characters (binary zero) are set in the start line column and the end line column of the old program 120.

(2) The value of NEW is set in the start line field of the correction program field.

(3) The value of NEW and the value of CNT1 are added, and a value obtained by adding -1 to the result is set in the end line column of the correction program column.

(4) “Add” is set in the add / delete / change column.

(5) The value of CNT1 is set in the additional row number column. In step S217, the value of NEW and the value of CNT1 are added, -1 is added to the addition result, and the result is set to NEW.
Substitute for Then, the process branches to step S193.

In step S221, 0 (zero) is set to CN
Set to T1.

In step S222, the value of CNT1 is set to 1
Is added, and the result is substituted into CNT1.

In step S223, OLD and CNT1
Of the old program 120 indicated by the result value and the correction program 11 indicated by the NEW value
It is determined whether the character string of the line number of 0 matches. If they do not match, OLD and C
The value of NT1 is added, and the result value is the old program 120
If the line number is not the last line, the flow branches to step S222, and if so, the flow branches to step S231.

In the step S225, the content of the difference 410
The following data (1) to (5) are added to (FIG. 9).

(1) The value of OLD is set in the start line field of the old program field.

(2) Each value of OLD and CNT1 and-
The total is set to 1 and the total is set in the end line column of the old program column.

(3) A null value (binary zero) is set in the start line column and the end line column of the correction program column.

(4) “Delete” is set in the add / delete / change column.

(5) A value obtained by subtracting CNT1 from 0 is set in the additional row number column.

In step S226, OLD and CNT1
, And a sum obtained by adding -1 to the added value, and the sum is substituted for OLD, and the flow branches to step S193.

In the step S231, the content of the difference 410
“Change” is set in the add / delete / change column of (FIG. 9),
In addition, the value in the end line column of the old program is changed to OLD value by -1.
It is determined whether or not a value obtained by adding is set. If it has been set, the flow branches to step S233.

In step S232, the following data (1) to (4) are added to the difference content 410 (FIG. 9).

(1) The value of OLD is set in the start line column and end line column of the old program.

(2) The value of NEW is set in the start line column and end line column of the correction program.

(3) “Change” is set in the add / delete / change column.

(4) “0” is set in the “number of additional lines” column. And
It branches to step S193.

In the step S233, the following correction is made to the difference content 410.

(1) The OLD value is set in the corresponding end line column of the old program column.

(2) The value of NEW is set in the corresponding end row column of the correction program column.

Then, the flow branches to step S193.

In step S241, the OLD value of the old program 120 is changed by a blank (blank), left parenthesis "(", right parenthesis ")", semicolon ";" or the like as a character string separator. The character string of the indicated line number is divided into a plurality of character strings using the separator.

In step S242, if the character string is divided into three or more, and the first character string is not a variable type name, the flow branches to step S245.

In the step S243, the execution part correction contents 4
The following data is set in 20.

(1) The second divided character string is set in the function name column.

(2) Set the value of OLD in the start line field of the old program.

In step S244, 0 (zero) is set to CN
Set to T1.

In step S245, the number of “$” is subtracted from the number of “$” existing in the line number of the old program 120 indicated by the value of OLD, and CNT1 is added to the calculation result. Substitute for

In step S246, the value of CNT1 is 0
Determine if it is (zero). If the value is not 0, the flow branches to step S196.

In step S247, step S243
The value of OLD is set in the end line column of the old program column of the execution part correction contents 420 added by (1). Then, the process branches to step S196.

In step S251, the NEW value of the correction program 110 is changed by a blank (blank), left parenthesis "(", right parenthesis ")", semicolon ";" or the like as a character string separator. The character string of the indicated line number is divided into a plurality of character strings using the separator.

In step S252, it is determined whether the character string is divided into three or more and the first character string is a variable type name. If it is not a variable name, the flow branches to step S257.

In step S253, execution unit correction contents 4
Whether data having the same value as the second divided character string is set in the function name column of No. 20 If not, the flow branches to step S255.

In step S254, step S253
The value of NEW is set in the corresponding part of the start line column of the correction program column of the execution part correction contents 420 selected in the step. Then, the process branches to step S256.

In the step S255, the execution part correction contents 4
The second divided character string is set in the corresponding location of the function name column of No. 20, and the value of NEW is also set in the start line column of the corresponding correction program column.

In step S256, 0 (zero) is set to CN.
Set to T1.

In step S257, the total number of “$” is subtracted from the total number of “$” existing in the line number of the correction program 110 indicated by the value of OLD, CNT1 is added to the result, and the addition result is Substitute for CNT1.

In the step S258, it is determined whether or not CNT1 is 0 (zero). If not 0, step S19
Branch to 9.

In step S259, step S245
Alternatively, the value of NEW is set in the corresponding end row column of the correction program column of the execution unit correction content 420 added in S255.

In step S261, as a separator of the character string, for example, a character string existing in the line number indicated by the OLD value by a blank (space), a colon ":", a left curly bracket "@", or the like. Is split into multiple strings.

In the step S262, it is determined whether or not the first divided character string is "class".
If "s", the second character string divided in step S263 is substituted for CLASS_NAME, and 0 (zero) is substituted for CNT1. Then, step S202
Branch to

In step S264, CLASS_NA
Determine whether the value of ME is not a null character (binary zero). If it is a value other than the null character, step S2
Branch to 71.

In step S265, the total number of “$” is subtracted from the total number of “$” existing in the line number of the old program indicated by the value of OLD, CNT1 is added to the result, and the addition result is substituted for CNT1. I do.

In step S266, the value of CNT1 is 0
If not, the flow branches to step S271.

In step S267, a null character (binary zero) is set in CLASS_NAME.

In step S271, a character string existing in the line number indicated by the OLD value by a blank (space), an equal sign "=", a semicolon ";" Split into columns.

In step S272, if the character string is divided into two or more, the process proceeds to step S273, and if not, the process proceeds to step S281.

In step S273, if the first character string obtained by the division represents the type of the variable (for example, an integer int), and if the second character string contains "(", the flow advances to step S274. Otherwise, the process proceeds to step S281.

In step S274, the following (1) to (4) are set in the variable declaration section correction contents 430.

(1) The second divided character string is set in the variable name column.

(2) The first divided character string is set in the variable type column.

(3) “Delete” is set as an initial value in an add / delete / non-change column.

(4) The value of OLD is set in the variable definition location column of the old program.

In step S275, CLASS_NA
If a null character is set in ME, the process branches to step S261.

In the step S276, the execution part correction contents 4
When the value set in the function name column of No. 20 is separated by “::”, if the first character string and CLASS_NAME are the same value, the process proceeds to step S277; otherwise, the process proceeds to step S202.

In the step S277, the step S274
The following (1)-
Set (2).

(1) The value of the start line column of the old program column of the execution part correction contents 420 extracted in step S276 is set in the start line column of the old program column of the corresponding correction contents 430.

(2) Set the end line of the old program column of the correction contents 430 corresponding to the end column of the old program column of the execution part correction contents 420 extracted in step S276.

Then, the flow branches to step S283.

In step S281, if the OLD value does not exist in the range of the line number from the start line column of the old program column to the corresponding end line of the execution part correction contents 420 (FIG. 10), the process proceeds to step S281. The process branches to S202.

In step S282, step S281
The old program start line in the variable effective range column of the variable declaration part correction contents 430 (FIG. 11) added in step S274 is replaced with the value of the old program start line column of the execution part correction contents 420 (FIG. 10) extracted in step S274. Field. Furthermore, the execution part correction contents 420 extracted in step S281 (FIG. 10)
Is set in the old program end line column of the variable effective range column of the variable declaration section correction details 430 (FIG. 11) added in step S274.

In step S283, step S274
A character string stored in the variable name field is searched using the variable name as a key in the variable effective range in the old program field of the variable declaration section correction contents 430 (FIG. 11) added in (1).
At this time, comment information (for example, a character string described between “/ *” and “* /”, a line described with “//” at the beginning) is excluded.

In step S284, step S283
In each line of the old program 120 extracted in step (1), a line is extracted in which character alphanumeric characters or underscore “_” are not included before and after a character string corresponding to a variable name.

At step S285, step S274
For the information (variable name, variable type, addition / deletion / change, and variable definition location) added to the modification content 430 (FIG. 11), a step is added to the old program column of the old program column of the variable usage location column. The line number of the old program extracted in S284 is set.

In step S 291, the correction program 1 is entered using blanks, semicolons “;”, left curly brackets “@”, etc. as character string separators.
At 10, the character string existing at the line number indicated by the value of NEW is divided into a plurality of character strings.

In step S292, if the divided first character string is "class", step S29
Substitute the second divided character string into CLASS_NAME as 3, substitute 0 (zero) into CNT1, and branch to step S205.

In step S294, CLASS_NA
If the value of ME is a null character, the flow branches to step S301.

In step S295, the total number of “$” is subtracted from the total number of “$” existing in the line number of the correction program 110 indicated by the value of NEW, CNT1 is added to the result, and the addition result is Substitute for CNT1.

At step S296, the value of CNT1 is 0
If so, the flow branches to step S297; otherwise, the flow branches to step S301.

At step S297, CLASS_NA
Set a null character (binary zero) to ME.

In step S301, the correction program 1 is modified by using a blank (space), an equal sign “=”, a semicolon “;” or the like as a character string separator.
At 10, the character string existing at the line number indicated by the value of NEW is divided into a plurality of character strings.

In step S302, if the number of the divided character strings is two or more, the process proceeds to step S303; otherwise, the process proceeds to step S312.

In step S303, if the first character string indicates an integer type "int", and if the second character string does not include a left parenthesis "(", step S3 is executed.
04, otherwise to step S312.

In step S304, a line in which the value of the addition / deletion / change column of the difference content 410 is "added" is extracted.

In step S305, N is set in the range from the start line to the end line column in the correction program column of the extracted line.
If the EW value is included, the flow branches to step S311.

At step S306, the difference content 410
The value of the number of additional lines smaller than the value of NEW in the end line column of the correction program column of FIG. 9 is totaled, and the total value is set to OLD. In step S307, OLD and NE
Sum the values of W and set the sum to OLD.

In step S308, in the line where the old program column of the variable definition portion column of the variable declaration section correction contents 430 (FIG. 11) matches the line number indicated by the OLD value,
“Unchanged” is reset in the Add / Delete / Unchange column, and NE is displayed in the modification program column of the corresponding variable definition location column.
Set the value of W.

In step S311, the following (1) to (4) are set in the variable declaration section correction contents 430.

(1) The first divided character string is set in a variable type column.

(2) The second divided character string is set in the variable name column.

(3) Addition is set in the addition / deletion / change column.

(4) The value of NEW is set in the correction program column of the variable definition location column.

In step S312, CLASS_NA
If the value of ME is a null character (binary zero), step S
Branch to H.321.

[0220] In step S313, execution unit correction contents 4
When the character strings stored in the function name column of FIG. 20 (FIG. 10) are separated by "::", if there is no character string whose first separated character string matches the value of CLASS_NAME, the flow branches to step S205.

In step S314, step S308
Alternatively, the start line column of the correction program column of the execution unit correction contents 420 extracted in step S313 is added to the start line column of the correction program in the variable effective range column of the variable declaration unit correction contents 430 (FIG. 11) added in step S311. Set the value of. Similarly, the value of the end line column of the correction program column of the execution part correction contents 420 extracted in step S313 is set in the end line column of the correction program of the variable effective range column of the variable declaration portion correction contents 430 (FIG. 11). I do.

In step S321, if the value of NEW is not included in the range between the values set in the start line column and the end line column of the correction program column of the execution part correction contents 420,
It branches to step S205.

In step S322, step S308
Alternatively, in the start line column and the corresponding end line column of the modification program column of the variable effective range column corresponding to the variable definition location column added to the variable declaration section modification content 430 in step S311,
The value of the start line field of the correction program field of the execution part correction content 420 extracted in step S321 is set.

At step S323, step S308
Alternatively, a character string is searched by using the variable name as a key in the variable effective range in the correction program column of the correction contents 430 (FIG. 11) of the variable declaration section added in step 311. At this time, comment information (for example, “/ *” and “* /”
, And lines beginning with “//” etc.) are excluded.

In step S324, step S323
In each row of the patch column searched and extracted in
The character string corresponding to the variable name column of the variable declaration section correction contents 430 extracts a line without an underscore "_".

In step 325, the contents 43 of the variable declaration section modification added in step 308 or step S311 are set.
The following values are added to the corresponding data table of 0. The line number of the correction program extracted in step S324 is set in the correction program column of the variable use location column. Then, the process branches to step S205.

[0227]

According to the present invention, there is provided a program correction content extracting section for comparing an old program with a correction program obtained by adding a correction to the old program, and storing a difference content relating to a variable described in both programs; The retest procedure editing unit that edits the old test procedure corresponding to the above based on the content of the difference and outputs the retest procedure corresponding to the correction program makes it possible to efficiently create a high quality retest procedure. I do.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating an example of a configuration of a conventional program test system.

FIG. 2 is a diagram for explaining a first configuration and an operation outline of the present invention.

FIG. 3 is a diagram for explaining a second configuration and an operation outline of the present invention.

FIG. 4 is a view for explaining an example of the configuration of a retest procedure generation system 900;

FIG. 5 illustrates a configuration example of a test system to which a retest procedure generation system 900 is applied.

FIG. 6 is a diagram illustrating an example of a program test procedure stored in an old test procedure.

FIG. 7 is a diagram for explaining an example in which a modification program is created by adding a change to an old program 120;

FIG. 8 is a view for explaining an example of an old test procedure 220 composed of old test procedures 221 to 224.

FIG. 9 is a view for explaining an example of a storage format of a difference content 410 stored in a program correction content 350.

FIG. 10 is a view for explaining an example of a storage format of execution part correction contents 420 stored in program correction contents 350;

FIG. 11 is a view for explaining an example of the storage format of variable declaration section correction contents 430.

FIG. 12 is a diagram for explaining an example in which an old test procedure is modified to a retest procedure when an old program is modified to a modified program.

FIG. 13 is a view for explaining a processing outline flow of the retest procedure generation system 900;

FIG. 14 is a processing flow (1) of a test procedure correction unit 320;
Diagram explaining

FIG. 15 is a processing flow (2) of the test procedure correcting unit 320;
Diagram explaining

FIG. 16 is a processing flow (3) of the test procedure correcting unit 320;
Diagram explaining

17 is a processing flow (1) of the test procedure adding unit 330. FIG.
Diagram explaining

FIG. 18 is a processing flow (2) of the test procedure adding unit 330;
Diagram explaining

FIG. 19 is a view for explaining a processing flow (1) of a program correction content extraction unit 310;

FIG. 20 is a view for explaining the processing flow (2) of the program correction content extraction unit 310;

FIG. 21 is a view for explaining a processing flow (3) of the program correction content extraction unit 310;

FIG. 22 is a view for explaining a processing flow (4) of the program correction content extraction unit 310;

FIG. 23 is a view for explaining the processing flow (5) of the program correction content extraction unit 310;

FIG. 24 is a view for explaining the processing flow (6) of the program correction content extraction unit 310;

FIG. 25 is a view for explaining the processing flow (7) of the program correction content extraction unit 310;

FIG. 26 is a view for explaining the processing flow (8) of the program correction content extraction unit 310;

FIG. 27 is a view for explaining the processing flow (9) of the program correction content extraction unit 310;

FIG. 28 is a view for explaining the processing flow (10) of the program correction content extraction unit 310;

FIG. 29 is a view for explaining the processing flow (11) of the program correction content extraction unit 310;

FIG. 30 is a view for explaining the processing flow (12) of the program correction content extraction unit 310;

FIG. 31 is a view for explaining the processing flow (13) of the program correction content extraction unit 310;

FIG. 32 is a view for explaining the processing flow (14) of the program correction content extraction unit 310;

[Explanation of symbols]

 Reference Signs List 50 terminal device 110 correction program 120 old program 150 compiler / linker 210 retest procedure 220 old test procedure 300 retest procedure editing section 310 program correction content extraction section 320 test procedure correction section 330 test procedure addition section 350 program correction content 400 object module 410 Difference contents 420 Execution part modification contents 430 Variable declaration part modification contents 500 Load module 600 Test system 610 Test execution unit 700 Test result 800 Load module 900 Retest procedure reproduction system

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Takeshi Matsunaga 2-2-1 Hyakuchihama, Sawara-ku, Fukuoka, Fukuoka F-term within Fujitsu Kyushu Communication Systems Co., Ltd. 5B042 HH10 HH17 HH42 HH49

Claims (15)

[Claims] A program modification content extraction unit that compares an old program with a modification program obtained by modifying the old program, and stores a difference content relating to a variable described in both programs; A retest procedure editing unit for editing a test procedure based on the content of the difference and outputting a retest procedure corresponding to the correction program. 2. The re-test procedure according to claim 1, wherein when the correction program is created by deleting a variable from the old program, the re-test procedure in which a test procedure relating to the variable is deleted from the old test procedure is output. A retest procedure editing method characterized by the following. 3. The re-test procedure according to claim 1, wherein, when a variable is added from the old program to create the correction program, the re-test procedure in which a test procedure relating to the variable is added from the old test procedure is output. A retest procedure editing method characterized by the following. 4. The retest procedure according to claim 1, wherein, when the modified program is created by changing a variable from the old program, the retest procedure in which a test procedure related to the variable is added or changed from the old test procedure. A retest procedure editing method characterized by output. 5. The variable according to claim 1, wherein when the modified program is created by changing an execution unit from the old program, the variable is placed before or after the location of the variable affected by the change. A retest procedure editing method characterized by outputting the retest procedure to which a test procedure relating to the retest is added. 6. In a system to which a retest procedure editing method for performing a test of a correction program according to a retest procedure is applied, an old program is compared with a correction program obtained by correcting the old program, and both programs are described. A program correction content extraction unit that stores a difference content relating to a variable; a retest procedure editing unit that edits the old test procedure corresponding to the old program based on the difference content and outputs a retest procedure corresponding to the correction program And a test execution unit that controls execution of an execution module created from the correction program in accordance with the retest procedure. A system to which a retest procedure editing method is applied. 7. The retest procedure according to claim 6, wherein, when the correction program is created by deleting a variable from the old program, the retest procedure in which a test procedure relating to the variable is deleted from the old test procedure is output. A system to which the retest procedure editing method is applied. 8. The re-testing procedure according to claim 6, wherein when the modification program is created by adding a variable from the old program, the re-test procedure in which a test procedure relating to the variable is added from the old test procedure is output. A system to which the retest procedure editing method is applied. 9. The retest procedure according to claim 6, wherein when the modification program is created by changing a variable from the old program, the retest procedure in which a test procedure related to the variable is added or changed from the old test procedure. A system to which a retest procedure editing method characterized by output is applied. 10. The method according to claim 6, wherein when the modified program is created by changing an execution unit from the old program, a variable affected by the change is added before or after the change. A retest procedure editing method, which outputs the retest procedure to which a test procedure has been added. 11. A program correction content extracting means for comparing an old program with a correction program obtained by adding a correction to the old program, and storing a difference content between variables described in both programs; A retest procedure editing means for editing a test procedure based on the content of the difference and outputting a retest procedure corresponding to the correction program; and a function for editing the old test procedure and outputting the retest procedure. A computer-readable recording medium recording a retest procedure editing program for realizing the same. 12. The retest procedure according to claim 11, wherein when the modified program is created by deleting a variable from the old program, the retest procedure in which a test procedure related to the variable is deleted from the old test procedure is output. A computer-readable recording medium on which a retest procedure editing program for realizing the function is recorded. 13. The retest procedure according to claim 11, wherein, when the correction program is created by adding a variable from the old program, the retest procedure in which a test procedure relating to the variable is added from the old test procedure is output. A computer-readable recording medium on which a retest procedure editing program for realizing the function is recorded. 14. The re-test procedure according to claim 11, wherein when the modification program is created by changing a variable from the old program, the re-test procedure in which a test procedure related to the variable is added or changed from the old test procedure. A computer-readable recording medium on which a retest procedure editing program for realizing the output function is recorded. 15. The variable according to claim 11, wherein when the modified program is created by changing an execution unit from the old program, a variable affected by the change is added before or after the change. A computer-readable recording medium recording a retest procedure editing program for realizing a function of outputting the retest procedure to which a test procedure has been added.