JP2002014847A - Device for checking program and method for the same and recording medium with checking program stored - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program checking device and a program checking method capable of selecting and executing only an absolutely necessary test case and a recording medium with a checking program stored. SOLUTION: This program checking device for checking the operation of a program by executing checking scripts prepared for respective program checking items is provided with an execution history storing means for storing execution history information indicating the execution of the checking scripts, a module information storing means for storing reference information related with modules constituting the program, an updated module extracting means for specifying the changed module and the changed contents by examining the reference information when the module is changed, and for extracting the module to be checked, and a checking item selecting means for specifying the execution history information including the extracted module to be checked from the execution history information, and for selecting the checking script corresponding to the specified execution history information.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program inspection apparatus, a program inspection method, and a recording medium storing a program for performing an inspection, which are used for testing and debugging a program.

[0002]

2. Description of the Related Art In recent years, computer programs have become more complicated and the number of steps has increased along with the diversification of information systems, and the functions of microcomputer-installed devices have also been diversified. It is complicated and bloated. Therefore, it takes a considerable amount of time and effort to inspect the functions and the like of the created program, and various mechanisms have been proposed to alleviate them.

FIG. 17 is a schematic configuration diagram showing a conventional typical mechanism for checking a program. The source program 101 is translated into an object program 105 by a compiler 102, and the translated object program 105 is executed on a debugger 108. The debugger 108 is a simulator 1 for simulating processing according to various test cases and test data.
08a and an emulator 108b.

An inspection script file 109 storing instructions, data, and the like according to a series of procedures for inspecting a program is prepared. The inspection script is a file described in a language for the debugger 108 (a script language for a debugger), and is created in advance for each test case. The debugger 108 sequentially and quasi-executes a series of instructions described in the test script file 109, and displays the processing result on a display unit (not shown) or the like.

By preparing such an inspection script file for each test case, the person in charge of program development can perform the work relating to the inspection semi-automatically, and repeatedly execute the same test case inspection. You can also
It has become possible to reduce the time and labor required for performing the inspection.

[0006]

However, for example, when a program developer changes a program, it is very difficult to examine the influence of the changed portion on the entire program.

This difficulty is particularly remarkable in the case of a module configuration in which control is dynamically shifted during execution of a program.

For example, as shown in FIG. 18, an event E occurs at a point P during execution of a process P1 of a program function func.
V, the control is transferred to the interrupt function interrupt_A, and after performing a predetermined process P2 in the interrupt function interrupt_A, the definition is returned to the point P of the original program function func. This is the case with If any change is made to the interrupt function interrupt_A, the influence of the change on the entire program cannot be clarified by examining the program source. In other words, even if you examine the program source of the function func,
A subordination with A cannot be revealed.

Further, as shown in FIG. 19, when the function func2 shown in FIG. 9D is changed, if the program source of the function func shown in FIG. However, if the function func3 shown in FIG. 11E, that is, the module using the function pointer as an argument is changed, even if the source code of the function func is examined, the dependency with the function func3 is obtained. I do not know. To clarify this dependency, the function fu shown in FIG.
The data can be traced back to nc0 and further analyzed by analyzing the data stored in the table array shown in FIG.

Also, when the function func2 shown in FIG. 1D is changed, it is actually difficult to reach the function func when the number of modules and the number of steps are large.

From the above, even if the change amount of the program is extremely small, if the influence range cannot be specified, the inspection script of all test cases is executed to execute the program. It is the present condition that guarantees quality. In other words, even if it is not necessary to actually execute the test scripts for all test cases, an enormous amount of test scripts must be executed to prevent test omissions.

As described above, since programs tend to be complicated and the number of steps tends to increase, it is considered that it will be increasingly difficult to investigate the range of influence accompanying a change in the program. In addition, it is conceivable that the number of inspection scripts increases as the number of test cases increases. Therefore, it is desired to improve a conventional inefficient inspection method in which an inspection script for all test cases must be executed every time a program is changed.

The present invention has been made in view of such problems, and when a change is made to a program, the range of influence of the change can be easily specified. An object of the present invention is to provide a program inspection apparatus, a program inspection method, and a recording medium storing a program for performing an inspection, which can reduce the amount of inspection by selecting and executing only the test case.

[0014]

According to the present invention, there is provided a program inspection apparatus for executing an inspection script prepared for each inspection item of a program to inspect the operation of the program. An execution history storage unit that stores execution history information that has executed the inspection script; a module information storage unit that stores reference information about modules that constitute the program; and when the module is changed, the By examining the reference information, the changed module and the contents of the change are identified, an update module extracting means for extracting a module that needs to be inspected, and execution history information including the extracted inspection required module is stored in the execution history information. From the list, and selects the inspection script corresponding to the specified execution history information. It includes a test item selecting means for a, and executes the test scripts that are selected.

[0015] The reference information includes dependency information indicating dependency of modules constituting the program, reference information indicating a reference relationship of variables, and definition information indicating a definition relationship of variables. It is characterized by the following.

If the change to the module is a change in the call processing of an external function, the update module extracting means identifies the module in which the change in the call processing of the external function has occurred by examining the dependency information. hand,
This module is extracted as a module requiring inspection.

If the change to the module is a change in the definition process of the external variable, the update module extracting means examines the definition information to identify the module in which the definition process of the external variable has changed and the definition. Identify the changed variable, extract this module as a module that needs to be inspected, further identify the module that refers to the identified variable by examining the reference information,
This module is extracted as a module requiring inspection.

If the change to the module is a change to an interrupt function, the update module extracting means identifies the interrupt function by examining the dependent information or the definition information, and specifies the interrupt function. Is extracted as a module requiring inspection.

If the change to the module is a change to a module using a pointer of a function as an argument, the update module extracting means examines the dependency information or the definition information to obtain the function pointer as an argument. The present invention is characterized in that a used module is specified and this module is extracted as a module requiring inspection.

According to the present invention, the change module and the contents of the change are specified from the reference information of the module stored in the module information storage means to extract the module which needs to be inspected. Since the history information is specified from the execution history information storing the execution history information of the inspection script, and the inspection script corresponding to the identified execution history information is selected, from among all the inspection scripts, It is possible to select and execute only an inspection script that really needs to be inspected.

Further, according to the present invention, even in the case of a module configuration in which control is dynamically transferred during execution of a program, a change module and its change contents are specified to easily extract a module that needs to be inspected. The execution history information including the extracted inspection required module can be easily selected from the execution history information.

Further, the program checking device is a program checking device for checking the operation of the program translated by the translating means, and the translating means translates the program into the module information storing means when translating the program. Is created / updated, and this reference information is examined to extract a module that needs to be inspected.

Further, the execution history information is trace information by a trace module for tracing the order of execution of the processing. When translating the program, the translating means includes, at the head of each module constituting the program to be translated, A processing code for calling the trace module is inserted.

[0024]

Embodiments of the present invention will be described below with reference to the drawings.

FIG. 1 is a schematic diagram showing an embodiment of a program checking apparatus according to the present invention. The program checking apparatus according to the present invention includes a compiler 2 for translating a source program 1 into an object program 5, a module management database 3 for storing reference information on modules constituting the program, and an update for extracting and outputting modules that need to be checked. Module ID information 4, an inspection script 9 storing instructions, data, and the like according to a series of procedures for performing an inspection, a trace information database 7 storing execution history information of execution of the inspection script 9 on a debugger 8, A search item selection device 6 that selects only the minimum inspection script 9 that requires inspection and sends it to the debugger 8
(A search item selection program).
The debugger 8 is a simulator 8a for simulating processing according to various test cases and test data.
And an emulator 8b.

First, as a pre-process, a process of creating the module management database 3 and the trace information database 7 will be described in detail. Here, the module is
Refers to an independent minimum unit (a function in the C language compiler) that constitutes a program.

FIG. 2 shows the configuration of the module management database 3. The module management database 3 includes module master information 10, symbol master information 20, and module reference information 30.

FIG. 3 shows the structure of the module master information 10. Module master information 10 includes module ID 1
1 and a module name 12, and one record is registered for each module. Module ID 11
Is a unique number assigned to each module, and is an internal code used to identify the module inside the program inspection apparatus.

FIG. 4 shows the structure of the symbol master information 20. Here, the symbol indicates a variable or a constant that can be externally referred to (a global variable or a const-defined constant in a C language compiler). The master information 20 has a symbol ID
21 and a symbol name 22, and one record is registered for each symbol. The symbol ID 21 is a unique number assigned to each module, and is an internal code used to identify the module inside the program inspection apparatus.

FIG. 5 shows the structure of the module reference information 30. This module reference information 30
One record is registered for each module, and the module ID 31, the number of modules 32 of the module group called (in a dependent relationship) in the module indicated by the module ID 31, and the module IDs 321 to 32 n
And cross-reference (cross-reference) information on symbols such as variables and constants appearing in the module indicated by the module ID 31. The cross-reference information on symbols such as variables and constants includes the number of symbols 33 in the group of symbols referred to among symbols appearing in the module indicated by the module ID 31.
And the symbol IDs 331 to 33m, the number of symbols 34 of the defined symbol group, and the symbol IDs 341 to 34
s.

Each of the above information constituting the module master information 10 is created / updated every time the compiler 2 compiles the source program 1.

Next, the trace information database 7 will be described. FIG. 6 shows the structure of the trace information database 7, which is composed of inspection script master information 50 and script trace information 60.

FIG. 7 shows the structure of the inspection script master information 50. In the inspection script master information 50, one record is registered for each inspection script file 9, and the inspection script ID 5 corresponding to the inspection script file 9 is registered.
0 and its script file name 52. These pieces of information are registered when the debugger 8 reads and executes the inspection script file 9.

FIG. 8 is a diagram showing the structure of the script trace information 60. In the script trace information 60, one record is registered for each inspection script file 9, the inspection script ID 50 corresponding to the inspection script file 9, and the number of modules 62 of a module group passed when the debugger executes the inspection script 9. And module IDs 621 to 62t. These pieces of information are stored in the inspection script file 9 by the debugger 8.
It is created each time a is read and executed.

FIG. 9 shows an example for acquiring trace information and writing the trace information in the script trace information 60 when the inspection script 9 is executed. When compiling the source program 1, the compiler 2 inserts a processing code 71 for calling the trace module 70 at the head of each module (here, _func) constituting the program, as shown in FIG. Generated as the object program 5. The present embodiment shows an example in which “0x1” is set as the module ID and the trace module 70 (_TraceMID) is called.

The trace module 70 writes the delivered module ID “0x1” at the write position (_TraceCur) of the trace memory (_TraceMem) 60, updates the write position (_TraceCur), and returns. As a result, in the trace memory (_TraceMem) 60, as shown in FIG.
The module ID “0x1” of c) is written. In this way, in the trace memory 60, the module ID is traced as an execution history in the order of passing through each module.

By the processing described above, each information of the module management database 3 and the trace information database 7 is created in advance. Thereafter, when a change occurs in the program, the module management database 3 is used to specify the changed module and the details of the change, and the trace information database 7 specifies the inspection script including the specified changed module. Used for

Next, an example of an operation for narrowing down the inspection script 9 that needs to be inspected in the inspection performed in accordance with the change of the source program 1 by using the above-prepared information described above. This will be described in detail with reference to the first to fourth embodiments.

(First Embodiment) In this embodiment, an example of a processing operation for narrowing down an inspection script 9 for which an inspection needs to be performed will be described, taking an example in which a normal function constituting the program 1 is modified. This will be described with reference to the flowchart of FIG. 11 and the image diagram of FIG.

First, functions constituting the source program 1
It is assumed that a calling process of the module c is added to func, for example, as shown in FIG. 12 (1) (Step 11). Compiler 2 starts compiling source program 1, and
To identify the changed module and its contents,
With reference to the registered information of the module reference information 30 in the module management database 3, it is checked whether or not the previously created reference information 30 is changed (Steps 12 to 13).

As a result of the investigation, as shown in FIG.
Since it is found that the module c is added to the module group called (subordinated) in the module of the module reference information 30 relating to the function func, the compiler 5 newly adds the information of the module c ( Step14). At this time, the number of dependent modules is 3
Add 1 to 2.

Next, since the reference information 30 of the function func has been changed in Step 14, the compiler 5 recognizes this function func as an update module that needs to be checked, and as shown in FIG. The function func is output as the update module ID information 4 (Step 15). As shown in FIG. 10, the updated module ID information 4 includes the number 41 of updated modules and their module IDs 411 to 41.
u.

Thereafter, the compiler 2 generates an object program 5 in which a trace module call process is inserted at the head of each module constituting the program 1 being compiled, and completes the compilation process (St.
ep16-Step17).

Next, the inspection item selection device 6 is activated (St
ep18), the inspection item selection device 6 extracts all install module IDs in the install module ID information 4 (Step 1).
9). Here, the module ID of the function func is extracted (FIG. 12 (3)).

Next, the inspection item selection device 6 searches the script trace information 60 for inspection script information including the update module ID, using the extracted update module IDs as keys (Step 20).

As a result of the search, the found inspection script becomes an inspection script that needs to be inspected.
In other words, the trace results that were actually operated in advance are searched, and the script containing the module that needs to be inspected is selected from among them. Only you can choose.

The inspection script file 9 corresponding to the found inspection script ID 61 is acquired from the inspection script master information 50 (Step 21 to Step 22). FIG.
As shown in (4), the script sc2 is the only inspection script including the function func which is the update module in the script trace information 60.

Next, the debugger 8 is started (Step 23),
The debugger 8 loads the compiled object program 5 into which the trace module calling process has been inserted (Step 24). Further, the inspection script sc2 selected by the inspection item selection device 6 is read and executed (Step 2).
Five). With the execution by the debugger, the script trace information 60 information is sequentially updated (Step 26).

As described above, execution history storage means for storing execution history information of execution of the inspection script,
A module information storage unit that stores reference information on modules constituting the program is created in advance, and when a change is made to a module, the created reference information is checked to determine whether the module has been changed. Modules and their changes can be identified to extract the modules that need to be inspected. Furthermore, execution history information including the extracted modules requiring inspection can be identified from the created execution history information and identified. The inspection script corresponding to the executed execution history information can be selected. Therefore, conventionally, it was necessary to execute all the scripts sc1 to sc3 to perform the inspection, but according to the present invention, it is sufficient to execute only the script sc2 that is truly necessary, and the amount of inspection can be reduced. The time and labor required for the inspection can be reduced.

The compiler has a function of creating / updating the reference information of the program and a function of examining the reference information and extracting a module that needs to be checked, and executes these functions when compiling the program. This can be performed semi-automatically, and human work can be further reduced.

Since the compiler has a function of inserting the trace module calling process into each module, human work can be further reduced.

(Second Embodiment) In the present embodiment, an inspection script which needs to be inspected, for example, in the case where an external variable defined among variables appearing in a module constituting the program 1 is corrected. An example of a processing operation for narrowing down 9 will be described with reference to a flowchart of FIG. 13 and an image diagram of FIG.

First, functions constituting the source program 1
Assume that an external variable c to be defined is added to func, for example, as shown in FIG. 14A (Step 31).

The compiler 2 starts compilation of the source program 1 and refers to the registration information of the module reference information 30 in the module management database 3 to identify and create the changed module and its contents. It is checked whether or not the reference information 30 has been changed (Steps 32 to 33).

As a result of the investigation, as shown in FIG.
Since it is found that the external variable c is added to the symbol group defined by the module reference information 30 relating to the function func, the compiler 5 newly adds information on the external variable c (Step 34 to Step 35). At this time, 1 is added to the number of symbols 34 to be defined.

Next, since the reference information 30 of the function func has been changed in Step 34, the compiler 5 recognizes this function func as an update module that needs to be checked, and outputs the function func as the update module ID information 4. (Step 36).

Next, it is determined whether or not a symbol to be defined has been added to the contents of this change, and if there is no symbol to be defined, the object program into which the calling process of the trace module is inserted, as in the first embodiment. 5 is generated and the compilation is terminated (Step 37, Step 41).

On the other hand, in the case where a symbol to be defined is added to the contents of the current change, that is, in the case of the second embodiment, the registration information of the module reference information 30 in the module management database 3 is referred to, and It is searched whether there is any other symbol that refers to the added symbol, that is, the external variable c (Step 38).

If there is another module that refers to the symbol added this time, the module is recognized as an update module that needs to be inspected and is created as update module ID information 4 (Step 39 to Step 40). As shown in FIG. 14 (3), when an external variable c is present in a symbol referred to in the module reference information 30 of the function func3, the function func3 is also recognized as an update module that needs to be checked. Output as update module ID information 4.

Since the function func is output as the update module ID information 4 in Step 36, the update module ID information 4 in this embodiment is composed of two functions func and func3 as shown in FIG. Becomes

Thereafter, the compiler 2 generates an object program 5 in which a trace module calling process is inserted at the head of each module constituting the program 1 being compiled, and completes the compiling process (St.
ep41-Step42).

Next, the inspection item selection device 6 is activated (St
ep43), the inspection item selection device 6 extracts all install module IDs in the install module ID information 4 (Step 4).
Four). Here, two module IDs of a function func and a function func3 are extracted (FIG. 14 (5)).

Next, the inspection item selection device 6 searches the script trace information 60 for inspection script information including the update module ID, using the extracted update module IDs as keys (Step 45).

The inspection script I found as a result of the search
The inspection script file 9 corresponding to D61 is acquired from the inspection script master information 50 (Step 46 to Step 4).
7). As shown in FIG. 14 (5), in the script trace information 60, the inspection script including the update module func is the script sc2, and the inspection script including the update module func3 is the script sc3.

Next, the debugger 8 is started (Step 48),
The debugger 8 loads the compiled object program 5 into which the trace module calling process has been inserted (Step 49). Further, the inspection scripts sc2 and sc3 selected by the inspection item selection device 6 are read and executed (Step 50). With the execution by the debugger, the script trace information 60 information is updated sequentially (Step
51).

As described above, conventionally, it was necessary to execute and inspect all of the scripts sc1 to sc3. However, according to the present invention, only the scripts sc2 and sc3 which are really necessary need to be executed. Inspection time and labor can be reduced.

(Third Embodiment) Next, an example of a processing operation for narrowing down an inspection script 9 which needs to be inspected, taking a module configuration in which control is dynamically shifted at the time of executing a program as an example. explain.

In this embodiment, as shown in FIG. 18, an event EV occurs at the point P during execution of the processing P1 of a certain program function func, and the interruption function interrupt_interrupt_
Control is transferred to A, and after performing a predetermined process P2 in the interrupt function interrupt_A, the definition is returned to the point P of the original program function func. Such an interrupt function interrupt_A
With reference to FIG. 15, a description will be given of an example of a processing operation for narrowing down the inspection script 9 that needs to be executed when some change is made to the above.

First, it is assumed that, for example, a process of calling a module y is added to the interrupt function interrupt_A constituting the source program 1 as shown in FIG.

The compiler 2 starts compiling the source program 1, refers to the registration information of the module reference information 30 in the module management database 3, and specifies and creates the changed module and its contents. It is checked whether or not the reference information 30 has been changed.

As a result of the investigation, as shown in FIG.
Since the module y is found to be added to the group of modules dependent on the module reference information 30 relating to the interrupt function interrupt_A, the compiler 5
Adds new information on module y.

Further, the compiler 5 has an interrupt function interrupt
Since the reference information 30 of t_A has been changed,
This interrupt function interrupt_A is recognized as an update module requiring a check, and is output as update module ID information 4 as shown in FIG.

Thereafter, the compiler 2 generates an object program 5 in which a trace module calling process is inserted at the head of each module constituting the program 1 being compiled, and the compiling process is completed.

Next, the test item selecting device 6 is activated, and the test item selecting device 6 extracts all the install module IDs in the install module ID information 4. Here, the interrupt function
The module ID of interrupt_A is extracted.

Next, the inspection item selection device 6 searches the script trace information 60 for inspection script information including the update module ID, using the extracted update module IDs as keys.

As a result of the search, the inspection script I found
The inspection script file 9 corresponding to D61 is acquired from the inspection script master information 50. As shown in FIG. 15D, the script sc2 is the only inspection script including the interrupt function interrupt_A, which is an update module, in the script trace information 60.

Next, the debugger 8 is started, and the debugger 8
Loads the compiled object program 5 into which the trace module calling process has been inserted. Further, the inspection script s selected by the inspection item selection device 6
Read and execute c2. With the execution by the debugger, the script trace information 60 information is sequentially updated.

(Fourth Embodiment) In this embodiment, when a change is made to a module using a function pointer as an argument as shown in FIG. An example of a processing operation for narrowing down will be described with reference to FIG.

First, the functions constituting the source program 1
Assume that a call process for module y is added to func3, for example, as shown in FIG.

The compiler 2 starts compiling the source program 1 and refers to the registration information of the module reference information 30 in the module management database 3 to identify the changed module and its contents. It is checked whether or not the reference information 30 has been changed.

As a result of the investigation, as shown in FIG.
Since the module y is found to be added to the group of modules that are dependent on the module reference information 30 for the function func3, the compiler 5 newly adds the information of the module y.

Next, since the reference information 30 of the function func3 has been changed, the compiler 5
Recognizing nc3 as an update module that needs to be inspected,
As shown in (3), it is output as update module ID information 4.

Thereafter, the compiler 2 generates an object program 5 in which a trace module calling process is inserted at the head of each module constituting the program 1 being compiled, and the compiling process is completed.

Next, the inspection item selection device 6 is activated, and the inspection item selection device 6 extracts all the install module IDs in the install module ID information 4. Here, the function func
The module ID of 3 is extracted.

Next, the inspection item selection device 6 searches the script trace information 60 for inspection script information including the update module ID, using the extracted update module IDs as keys.

As a result of the search, the inspection script I found
The inspection script file 9 corresponding to D61 is acquired from the inspection script master information 50. As shown in FIG. 16D, the inspection scripts including the function func3 as the update module in the script trace information 60 are scripts sc2 and sc3.

Next, the debugger 8 is activated, and the debugger 8
Loads the compiled object program 5 into which the trace module calling process has been inserted. Further, the inspection script s selected by the inspection item selection device 6
c2 and sc3 are read and executed. With the execution by the debugger, the script trace information 60 information is sequentially updated.

As described above with reference to the third embodiment and the fourth embodiment, even in the case of a module configuration in which control is dynamically shifted during execution of a program, the trace result actually operated in advance is used. Is searched, and a script including a module that needs to be inspected is selected from among them, so that only the minimum necessary test cases can be selected without omission of inspection.

Although the present invention has been described in detail, the present invention is not limited to the present embodiment, and various improvements and modifications may be made without departing from the gist of the present invention.

For example, in the present embodiment, an example in which the function call processing and the external variable definition processing are changed as the change items considered to affect the entire program has been described. It can be easily implemented according to the embodiment.

Further, in the present embodiment, the program in the C language has been described as a model, but the present invention is widely applicable to programs in other languages.

The method described in the present embodiment can be stored in various recording media as a program that can be executed by a computer, and can be transmitted and distributed via a communication medium. A computer that realizes the present apparatus is operationally controlled by the program recorded on the recording medium, and executes each process according to the above method.

[0093]

According to the present invention, by examining the created reference information, it is possible to identify the changed module and the contents of the change, and to extract the module which needs to be inspected. Identify the execution history information including the extracted modules requiring inspection from the created execution history information, and easily execute the inspection script corresponding to the identified execution history information, that is, only the inspection script that really needs to be inspected. Can be selected. Therefore, it is not necessary to execute all the inspection scripts as in the related art, and only the minimum required script needs to be executed. Therefore, the inspection amount can be reduced, and the inspection time and labor can be reduced. it can.

The compiler is provided with a function of creating / updating the reference information of the program and a function of examining the reference information and extracting a module which needs to be inspected. When compiling the program, these functions are automatically performed. Can be performed and human work can be further reduced.

Since the compiler has a function of inserting the trace module calling process into each module, human work can be further reduced.

Furthermore, even in the case of a module configuration in which control is dynamically transferred during execution of a program, a trace result actually operated in advance is searched, and a script including a module that needs to be inspected is searched. Is selected, it is possible to select only the minimum necessary test cases without any omission of inspection.

[Brief description of the drawings]

FIG. 1 is a schematic configuration diagram showing an embodiment of a program inspection device according to the present invention.

FIG. 2 is a schematic configuration diagram showing a configuration example of a module management database.

FIG. 3 is a schematic diagram illustrating a layout example of module master information.

FIG. 4 is a schematic diagram showing a layout example of symbol master information.

FIG. 5 is a schematic diagram illustrating a layout example of module reference information.

FIG. 6 is a schematic configuration diagram showing a configuration example of a trace information database.

FIG. 7 is a schematic diagram showing a layout example of inspection script master information.

FIG. 8 is a schematic diagram illustrating a layout example of script trace information.

FIG. 9 is an image diagram for explaining a method for acquiring script trace information.

FIG. 10 is a schematic diagram illustrating a layout example of update module ID information.

FIG. 11 is a flowchart illustrating a procedure of a program inspection process according to the first embodiment;

FIG. 12 is an image diagram for explaining a processing procedure of a program checking process according to the first embodiment.

FIG. 13 is a flowchart illustrating a processing procedure of a program checking process according to a second embodiment.

FIG. 14 is an image diagram for explaining a processing procedure of a program checking process according to the second embodiment.

FIG. 15 is an image diagram for explaining a processing procedure of a program checking process according to the third embodiment.

FIG. 16 is an image diagram for explaining a processing procedure of a program inspection process according to a fourth embodiment.

FIG. 17 is a schematic configuration diagram showing a conventional typical program inspection device.

FIG. 18 is an image diagram for describing a program configuration including an interrupt function.

FIG. 19 is an image diagram for describing a program configuration including a module using a function pointer as an argument.

[Explanation of symbols]

 1. Source program 2. Compiler 3. Module management database 4. Update module ID information 5. Object program 6. Inspection item selection device 7. Trace information database 8. Debugger 9. Inspection script 10. Module master information 11. Module ID 12. Module name 20. Symbol master information 21. ... Symbol ID 22 ... Symbol name 30 ... Module reference information 31 ... Module ID 32 ... Number of modules with dependent relationship (n) 321 to 32n ... Dependent relationship Module ID with a symbol 33 .... Number of referenced symbols (m) 331-33m .... Referenced symbol ID 34 .... Number of defined symbols (s) 341-34s .... Definition Symbol ID 41 to be updated 41. Number of updated modules (u) 41 ... 41u .... Updated module ID 50 .... Inspection script master 51 .... Script ID 52 .... Script name 60 .... Script trace information 61 .... Script ID 62. ... Number of passed modules (t) 621-62t ... Module ID passed 70 ... Trace module 71 ... Trace module call processing

Claims (11)

[Claims] 1. A program inspection apparatus for executing an inspection script prepared for each inspection item of a program and inspecting the operation of the loaded program, wherein execution history information of the execution of the inspection script is stored. An execution history storage unit, a module information storage unit that stores reference information about modules that constitute the program, and a module that has been changed by examining the reference information when a change has been made to the module. An update module extracting unit that identifies the contents of the change and extracts a module that needs to be inspected; and identifies execution history information including the extracted inspection required module from the execution history information, and corresponds to the identified execution history information. Inspection item selection means for selecting the inspection script to be performed. Program inspection device, characterized in that executing the test scripts. 2. The reference information includes dependency information indicating dependency of modules constituting the program, reference information indicating a reference relationship of variables, and definition information indicating a definition relationship of variables. The program inspection device according to claim 1, wherein: 3. When the change to the module is a change in the call processing of an external function, the update module extracting unit examines the dependent information to determine a module in which the change in the call processing of the external function has occurred. 3. The program inspection apparatus according to claim 2, wherein the module is specified and extracted as a module requiring inspection. 4. When the change to the module is a change in a definition process of an external variable, the update module extracting unit examines the definition information to determine a module in which a change in the definition process of the external variable has occurred. Identify the variable whose definition has been changed, extract this module as a module that needs to be inspected, further identify the module that references the identified variable by examining the reference information, and inspect this module. The program inspection device according to claim 2, wherein the program is extracted as a required module. 5. When the change to the module is a change to an interrupt function, the update module extracting unit specifies the interrupt function by examining the dependent information or the definition information, and 3. The program inspection apparatus according to claim 2, wherein the embedded function is extracted as a module requiring inspection. 6. When the change to the module is a change to a module using a pointer of a function as an argument, the update module extracting unit checks the dependency information or the definition information to determine a pointer of the function. 3. The program inspection apparatus according to claim 2, wherein a module used as an argument is specified, and the module is extracted as a module requiring inspection. 7. The program checking device is a program checking device for checking the operation of the program translated by the translating means. The translating means translates the program into the module information storage means when translating the program. 7. The program inspecting apparatus according to claim 1, wherein the reference information is created / updated, and the reference information is examined to extract a module that needs to be inspected. 8. The execution history information is trace information by a trace module that traces an execution order of processing. When translating the program, the translating means includes, at the head of each module constituting the program to be translated, The program inspection apparatus according to claim 7, wherein a processing code for calling the trace module is inserted. 9. A program inspection method for executing an inspection script prepared for each inspection item of a program, and inspecting the operation of the loaded program, and relates to a module constituting the program in advance. Create and store reference information, store execution history information of the execution of the inspection script, and, when a change is made to the module, investigate the reference information and check the changed module and its Identify the contents of the change, extract the module that needs to be inspected, identify the execution history information including the extracted module requiring inspection from the execution history information, and specify the inspection script corresponding to the identified execution history information. A program inspection method, comprising selecting and executing the selected inspection script. 10. A recording medium storing a program for executing an inspection script prepared for each inspection item of an inspection target program and inspecting an operation of the inspection target program. Creating and storing reference information about the modules to be configured; examining the reference information to identify changed modules and their changes, and extracting modules that need to be inspected; Identifying execution history information including a module from the execution history information, selecting the inspection script corresponding to the identified execution history information; executing the selected inspection script; Storing the execution history information of the execution of the script for use, A recording medium storing a program to be executed. 11. A recording medium storing a program for executing an inspection script prepared for each inspection item of a program to be inspected and inspecting the operation of the program to be inspected. Translating; creating and storing reference information on modules constituting the program under test; inserting a processing code for calling a trace module at the beginning of each module to be translated; and examining the reference information. Identifying the changed module and the contents of the change, and extracting a module that needs to be inspected; identifying execution history information including the extracted module requiring inspection from the execution history information; Selecting the inspection script corresponding to the history information; A storage medium storing a program, comprising: a step of executing the specified inspection script; and a step of storing a trace result of executing the inspection script as execution history information.