JP4458491B2 - Test command file creation system, method and program - Google Patents

Description

  The present invention relates to a technique for creating a command file (test command file) used when testing the operation of a program executed by a computer with a debugger, and particularly suitable for facilitating the creation of a test command file. It is about.

  Conventionally, creating a test command file to be used when checking the operation of a program using a debugger is done manually by creating a test command file template file that is output by compiling the program. It was done by adding or modifying necessary test commands while referring to the design.

  The test command file created in this way is, for example, a sequence of commands input from the gdb command prompt in the debugger “gdb” provided by GNU. By using the “−x” option, etc. , Can be automatically loaded and executed at startup.

  However, in order to create a test command file by manually spreading two or more specification documents, a test command file can be used by a worker who does not have a tabletop area or who does not use a command file such as a newcomer. It takes time to understand, and it takes time to do the actual test.

  In addition, if the program that created the test command file is modified, the line numbers on the compilation of the program will be shifted, so it will not be possible to retest with the previously created command file, and it will be necessary to create the test command file again. And takes time.

  As a technique for facilitating the creation of such a test command for debugging, there are techniques described in Patent Documents 1 to 4, for example.

  Patent Document 1 describes a conventional first test command generation technique having a problem to be solved and a second test command generation technique for solving this problem.

  In the first test command generation technique, first, a source program created according to a programming language is translated into a machine language executable program that can be decoded and executed by a computer by a translation program (compiler). Generate. However, since this test command file contains only the source program, there is insufficient information and only standard test commands are generated.

  Therefore, before using the symbolic debugger, the user (programmer) starts the editing program from the display terminal, changes the test command in the test command file to the information to be tested, and creates the edited test command file. To do.

For example, a primitive program
"01 CODE PIC X (4)-Data definition
01 TANKA PIC 9 (8), data definition
PROCEDURE DIVISION
USING CODE TANKA
Suppose that

  In this case, according to the attribute, “CODE” is a 4-byte character, so “(X (4))”, the test command before editing (unfinished test command) generated by the translation program (compiler) includes: Since “CODE = ABCD” is set and “TANKA” is an 8-digit number, “(9 (8))” is set, and “TANKA = 12345678” is set as the test command before editing (incomplete test command). Is set. In this way, only standard values are set for incomplete test commands generated by the translation program (compiler).

  Therefore, the user (programmer) edits the test command file to information to be tested using an editing tool before debugging. That is, in this example, “A105” is set in “CODE” and “1200” is set in “TANKA” according to the data name.

  On the other hand, the second test command generation technique eliminates the editing work performed before debugging in the first test command generation technique and simplifies the test preparation work. When a dictionary information file in which data values corresponding to names are registered is provided and the source program is compiled, the dictionary information file is searched using the program name of the source program as a key, and the data corresponding to the data name in the source program A value is read from the dictionary information file, and a test command file in which the read data value is set is generated.

  Thus, in the dictionary information file, a value to be set corresponding to the data name is registered in advance, and the translation program that reads the contents of the source program searches the dictionary information file using the program name of the source program as a key, The setting value registered in the dictionary information file corresponding to the data name of the source program is read and set in the test command file. This eliminates the need to edit the test command file for setting the environment input to the symbolic debugger.

  However, in the first test command generation technology, the test command file is edited and created only on the display terminal instead of spreading two or more specification documents. Even in command generation technology, the same work is required to register data values in the dictionary information file. In both cases, a new worker takes time to understand the test command, and the actual test is performed. It takes time to do it.

  Patent Document 2 discloses a technique for debugging a computer program by the interaction between a simulator and a debugger. A debug command is embedded in a source program in advance, and the source program in which the debug command is embedded is assembled to generate an object code. When creating a command file by extracting the debug command, generating a breakpoint command corresponding to each debug command, writing the breakpoint command and the corresponding debug command to the debug command file, and When the source program is modified, the breakpoint command and the corresponding embedded debug command are removed from the debug command file and modified accordingly. During reassembly of the source program are described automatically creates art each new command file containing the new breakpoint command corresponding to the embedded debug command in the new relative position of the source.

  However, even in the technique described in Patent Document 2, it takes time for a worker who does not test using a command file, such as a newcomer, to embed a debug command in advance in a source program. It takes time to test.

  Patent Document 3 discloses that in a unit test and a partial combination test of a program composed of a plurality of modules performed using a debugger, the test can be started without performing preprocessing such as stub creation or setting of an external variable. The technology which made the problem a subject is described.

  In other words, a variable reference management table for variables that are not in the program under test, such as global variables, is provided in the debugger, and each time such a variable is referenced, the table is referenced and an appropriate value is already set. If it is not set yet, or if it is necessary to change the value for testing, the user (operator) can specify the value on the spot and use the debugger command. Generate and execute. This user instruction is saved as a debug command file so that the same operation does not have to be performed in subsequent retests or similar tests.

  However, even in the technique described in Patent Document 3, with respect to generation of a variable reference management table and specification of a value by a user when a value has not yet been set, a test is performed using a command file such as a new face. It takes time for workers who have not done so, and it takes time to actually test.

  Patent Document 4 describes a technique for generating a test command for a debugger corresponding to a test target program by an interactive operation with an operator using a window screen.

  In this technique, first, when a program to be tested is specified in the displayed “program display window”, the specified “program” is displayed in the form of “graphic editor” in the “program display window” ( (It may be in the form of a direct program source).

  Next, in the “program” displayed in this “graphic editor format”, when “data item of interest” is designated with the mouse and “extract in file menu” is selected, “test data editor window” A “Program Source Extraction Window” is generated and displayed.

  When “Extraction option setting” in “Option” is specified in the “Program display window”, for example, “reference data item use instruction” and “branch instruction” are displayed. These “reference data item” and “branch instruction” are also displayed in the “test data editor window” and “program source extraction window”.

  Then, referring to this “program source extraction window”, when “data value” is set in the “test data editor window” and “test command generation” is specified in the “program source extraction window”, the data A “test command” with a value set is generated.

  In this way, according to the technique described in Patent Document 4, it is possible to generate a test command for a debugger corresponding to a test target program by an interactive operation with an operator using a window.

  However, even in the technique described in Patent Document 4, it is input in the “test data editor window” and the “program source extraction window”, and the operator has to understand the contents of the coding level of the program. The input work is difficult.

  In the technique described in Patent Document 4, breakpoints are generated in all branches, files, and external routines, and the test commands are received by inputting the contents input from the “test data editor window” and the “program source extraction window”. Depending on the program, the test command sentence becomes long and the test command is difficult to see. Moreover, since the execution result of the breakpoint is displayed in the test result that is output unnecessarily in the test, there is a problem that the test result is difficult to see.

  Furthermore, in the technique described in Patent Document 4, the test command is changed from the screen and saved under a different file name. You may forget what you want to test by entering a simple value, and this may make the test command you create unnecessary. For example, after performing other work in the middle of work, the worker may not be able to instantly remember under what conditions such a value is set, and may make a mistake.

  Further, for example, as described in Patent Literature 5, Patent Literature 6, and Patent Literature 7, there is a technique for analyzing a program so that it can be visually confirmed. Furthermore, as described in Patent Document 8, there is a support technology for creating a PAD (Problem Analysis Diagram) and a technology for creating a program source from the PAD.

  However, these conventional technologies cannot create a test command file from a program.

JP-A-7-84828 JP-A-8-272648 JP 2001-229044 A Japanese Patent Laid-Open No. 6-250883 Japanese Patent Laid-Open No. 5-119989 JP-A-5-313870 JP-A-6-314191 JP-A-10-91411

  The problem to be solved is that the conventional technology cannot easily create a test command file for a program for a beginner who does not know the contents and language of the program to be tested by debugging. .

  An object of the present invention is to solve these problems of the prior art, to immediately respond to changes in the skill and test status of the worker, and to make it possible for anyone such as newcomers to easily create a test command file. .

  In order to achieve the above object, the present invention performs lexical analysis and syntax analysis of the source program, generates an analysis result table of the definition part and an analysis result table of the execution part, and sets each item in the analysis result table of the definition part. Generates a simulation sheet consisting of a list and a field for inputting debug setting information from the operator including data values for each item, and from the list of each instruction in the analysis result table of the execution unit and from the operator for each instruction Generate breakpoint sheets consisting of fields for entering debug control information, including whether breakpoints need to be set, and display these breakpoint sheets and simulation sheets on the screen. Information specified by the operator is set for the sheet and simulation sheet, and such operations are performed. And generating a test command file using the sheet and simulation sheet for the specified input information is set breakpoint. Furthermore, from the analysis result table of the execution unit, a PAD corresponding to the source program is generated and displayed on the display device, and the execution used to generate the PAD at the location specified by the operator operating the input device in the displayed PAD The information in the analysis result table of the part is read out and displayed at the corresponding location, and the information in the analysis result table of the displayed execution part is set in the breakpoint sheet according to the operation instruction from the operator input device It is characterized by that.

  According to the present invention, it is possible to easily cope with changes in the skill and test status of an operator, and it is possible for anyone such as a new employee to easily create and recreate a test command file.

  The best mode for carrying out the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing a configuration example of a test command file creation system according to the present invention, FIG. 2A is an explanatory diagram showing a first specific example of a program source in FIG. 1, and FIG. 2B is a diagram in FIG. It is explanatory drawing which shows the 2nd specific example of a program source.

  3 is an explanatory diagram showing a specific example of the analysis result sheet (definition unit) in FIG. 1, FIG. 4 is an explanatory diagram showing a specific example of the analysis result sheet (execution unit) in FIG. 1, and FIG. FIG. 6 is an explanatory diagram showing a specific example of the simulation sheet in FIG. 1, FIG. 6 is an explanatory diagram showing a specific example of the breakpoint sheet in FIG. 1, and FIG. 7 is a specific example of the PAD created by the PAD creation unit in FIG. It is explanatory drawing which shows an example.

  8 is a flowchart showing a first processing operation example according to the present invention of the test command file creation system in FIG. 1, and FIG. 9 is a second process according to the present invention of the test command file creation system in FIG. FIG. 10 is a flowchart showing a third processing operation example according to the present invention of the test command file creation system in FIG. 1, and FIG. 11 is a flowchart according to the present invention of the test command file creation system in FIG. FIG. 12 is a flowchart showing a fifth processing operation example according to the present invention of the test command file creation system in FIG.

  FIG. 13 is an explanatory diagram showing an example of an operation screen for selecting a breakpoint setting. FIG. 14A is an explanatory diagram showing a first specific example of a test command file created by the test command file creation system in FIG. 14B is an explanatory diagram showing a second specific example of the test command file created by the test command file creation system in FIG. 1, and FIG. 14C is a third test command file created by the test command file creation system in FIG. It is explanatory drawing which shows a specific example.

  The program analysis system of this example shown in FIG. 1 has a computer configuration including a CPU (Central Processing Unit), a main memory, a display device, an input device, and an external storage device, and a CD-ROM (Compact) via an optical disk drive device or the like. After a program or data recorded on an optical disk such as a Disc-Read Only Memory (DVD) or DVD (Digital VIDeo Disc / Digital Versatile Disc) is installed in the external storage device, the program is read from the external storage device into the main memory and processed by the CPU. By doing so, the function of each processing unit is executed.

  In FIG. 1, 1 is an input device composed of a keyboard, a mouse, etc., 1a is a display device composed of a CRT (Cathode Ray Tube), LCD (LiquID Crystal Display), etc., and 2a, 2-6 are each realized by executing a program of a CPU. Program control unit 2a (denoted as “program control (button operation)” in the figure), program analysis unit 2 (denoted as “program analysis” in the figure), and input sheet creation unit 3 (denoted as “input sheet creation” in the figure) ”, A PAD creation unit 4 (described as“ PAD creation ”in the figure), a PAD control unit 5 (described as“ PAD control ”in the figure), a test command file creation unit 6 (“ test command file ”in the figure) Description).

  7 to 14 are data generated by the CPU program execution and stored in the storage device, 7 is a test command file creation target program (described as “program source” in the figure), and 8 is used by the program 7. Directories that are copy phrase groups (indicated as “copy phrase” in the figure), 9 and 10 are an analysis result sheet (definition part) (9) and an analysis result sheet (execution part) (10) created by the program analysis part 2, respectively. , 11 and 12 are a simulation sheet (11) and a breakpoint sheet (12) created by the input sheet creation unit 3, 13 is a PAD created by the PAD creation unit 4, and 14 is a test command of this example. This is a test command file created by the file creation system.

  As shown in FIGS. 2A and 2B, the program 7 includes a variable part 15 used in the program 7 and an execution part 16 of the program 7.

  The program control unit 2a includes a program analysis unit 2, an input sheet creation unit 3, a PAD creation unit 3, a PAD control unit 5, a test command file in accordance with an instruction input operation such as addition or correction by the operator on the input device 1. Starts and controls the creation unit 6.

  The program analysis unit 2 divides the analysis of the program 7 into a variable part 15 and a program execution part 16 shown in FIGS. 2A and 2B according to the procedure shown in FIG. 8, and the analysis result sheet (detailed in FIG. 3) (Definition part) 9 and an analysis result sheet (execution part) 10 whose details are shown in FIG.

  The input sheet creation unit 3 executes the procedure shown in FIG. 9 using the analysis result sheet (definition unit) 9 and the analysis result sheet (execution unit) 10 which are the analysis results of the program analysis unit 2, and details are shown in FIG. 6 and a breakpoint sheet 12 shown in detail in FIG. 6 are generated and output to the display device 1a.

  The PAD creation unit 4 executes the procedure shown in FIG. 10 using the analysis result sheet (definition unit) 9 and the analysis result sheet (execution unit) 10 which are the analysis results of the program analysis unit 2, and details are shown in FIG. The PAD 13 shown is created and output to the display device 1a.

  The PAD control unit 5 executes the procedure shown in FIG. 12 in response to an instruction input operation such as addition or correction by the operator of the input device 1 with respect to the PAD 13 created by the PAD creation unit 4 and displayed on the display device 1a. Then, auxiliary input such as addition and correction to the breakpoint sheet 12 is performed.

  The test command file creation unit 6 executes the procedure shown in FIG. 11 using an input sheet including a simulation sheet 11 and a breakpoint sheet 12, and creates and outputs a test command file 14.

  The processing operation according to the present invention of the test command file creation system having such a configuration will be specifically described below.

  As shown in FIG. 8, the program analysis unit 2 performs processing in the order of a program all-line fetch procedure 60, a line number renumbering procedure 61, a definition unit analysis procedure 62, and an execution unit analysis procedure 63. The program all-line fetching procedure 60 sequentially reads the program 7 described in “COBOL” shown in detail in FIGS.

  Then, an analysis process is performed on the definition statement of the COBOL in the definition part analysis procedure 62, and an analysis process of the execution process of the COBOL is performed in the execution part analysis procedure 63, thereby performing an analysis process on all steps (syntax) of the entire program. Do.

  In the program all line fetching procedure 60, the procedure of inputting one line from the program file, the procedure of counting the number of input lines by one, and the procedure of stacking the input lines in an array (internal memory) are repeated until the program file becomes EOF. Read all lines of the program.

  In the line number renumbering procedure 61, “0” is set in the line number stack, and then the following procedure is repeated for the data i stacked in the array in the all-line fetching procedure 60 of the preprocessing program. First, it is determined whether or not the line number stack is “0”. If it is not “0”, it is determined whether or not the first six digits of the array (i) are equal to or greater than the line number stack. For example, the first 6 digits of the array (i) are set in the line number stack, and if not, the first 6 digits of the array (i) are set in the digit line number stack.

  Thereafter, or if it is “0” in the determination of whether or not the line number stack is “0”, it is determined whether or not the array (i) is a copy statement.

  If it is a copy statement, set the number of copy phrase lines to “0”, repeat counting up the number of copy phrase lines until the copy phrase file reaches EOF, and then add the number of copy phrase lines to the digit line number stack. .

  After that, or when it is determined whether the array (i) is a copy sentence or not, if it is not a copy sentence, the process proceeds to the next array.

  The definition part analysis procedure 62 creates a state where the COPY phrase (8) is expanded for the creation of the simulation sheet 11 and the breakpoint sheet 12 by the input sheet creation part 3 and the creation of the PAD 13 by the PAD creation part 4. The variable part (definition) 15 from the beginning to the execution part 16 is expanded with the contents shown in FIG. 3 to generate an analysis result sheet (definition part) 9.

  That is, in the definition part analysis procedure 62, the contents of the array i are read from the program file until the “PROCEDURE DIVISION” statement in the execution part 16 appears for the number of arrays (stacks) i. ”Or“ COPY phrase related ”, and processing according to each determination result is performed.

  For example, if the contents of the array i are neither “program ID” nor “file related” but “COPY phrase related”, it is determined whether or not COPY phrase expansion is necessary. If necessary, COPY is determined. The COPY phrase file contains an EOF procedure for inputting one line from the phrase file, a procedure for setting the contents of one line read from the COPY phrase in the analysis result sheet (definition part) 9, and a procedure for counting the number of set lines by one. Repeat until.

  If the contents of the array i are “file related”, it is determined whether or not COPY phrase expansion is necessary. If necessary, a procedure for inputting one line from the COPY phrase file and reading from the COPY phrase are performed. The procedure for setting the contents of one line in the analysis result sheet (definition section) 9 and the procedure for counting the number of set lines by one are repeated until the COPY phrase file becomes EOF.

  If the content of the array i is “program ID”, it is saved in a global memory and set in the analysis result sheet (definition part) 9. The “program ID” saved in the global memory is used to create a breakpoint sheet and PAD later.

  In this way, the program analysis unit 2 uses the definition unit analysis procedure 62, as shown in FIG. 3, as the analysis result sheet (definition unit) 9, the FILE logical unit name 17 (only the definition related to the file is set), the structure It expands to a body symbol name 18 (01-level item symbol name in the case of a structure), a level 19, an item symbol name 20, an attribute 21, and a digit number 22.

  The execution part analysis procedure 63 expands the execution part 16 (instruction group) of the program for the creation of the simulation sheet 11 and the breakpoint sheet 12 by the input sheet creation part 3 and the creation of the PAD 13 by the PAD creation part 4. The analysis result sheet (execution unit) 10 is generated by developing the processing contents shown in FIG.

  That is, in the execution unit analysis procedure 63, the following processing is repeated for the number of arrays (the number of stacks) i from the “PROCEDURE DIVISION” sentence to the end in the execution part 16 of the program.

  First, the contents of the array i are set in the analysis sentence area. By using this “analysis sentence area”, a syntax extending over a plurality of lines can be connected to one syntax.

  For example, if a part of the array is “array (i) = MOVE '1 ′” in one row and “array (i + 1) = TO AITEM.” In the next row, first, the array ( The contents of i) (MOVE '1') are put in the analysis sentence area. This portion is the above-described process of “setting the contents of array i in the analysis sentence area”.

  Next, the contents (TO AITEM.) Of the array (i + 1) are connected to the analysis sentence area by the following “syntax connection processing”, and as a result, the contents of the analysis sentence area are “MOVE '1 ′ TO AITEM.”. "

  In “Syntax Joining”, first, by setting a space as the loop end flag, clearing (initializing) the flag that indicates the end of the process of joining the syntax that spans multiple lines, then the array ( In i + 1), the connection process is repeated until “END” is set in the loop end flag (connection process loop).

  In this connection processing loop, it is determined whether or not a main command statement group exists in the array (i + 1). If there is, a loop end flag is set to “END” so as to exit the connection processing loop. If it does not exist, it is determined whether or not the main command statement in the array (i + 1) is an end statement. If it is an end statement, “END” is set in the loop end flag to exit the connection processing loop. If the sentence is not an end sentence, the first 7 characters to the 72nd character of the array (I + 1) are concatenated and stored in the analysis sentence area, and then the extra space is eliminated.

  In a specific example in which it is determined whether or not the process of connecting syntaxes extending over a plurality of lines has been completed, for example, the next to “array (i + 1) = TO AITEM.” Described above is “array (i + 2) = "PERFORM A_SUB USING AITEM, BITEM.", It is determined that the process is finished.

  That is, since “PERFORM” in the array (i + 2) is one of COBOL command statements, the “MOVE” statement in “array (i) = MOVE '1 ′” ends with array = i + 1.

  In this way, in the process of connecting this syntax, the state one step ahead is determined, and it is determined whether the syntax ends in one step or multiple steps.

  When “END” is set in the loop end flag and the connection processing loop is exited, the hierarchical level of the statement is calculated, and the calculated hierarchical level and the content stored in the analysis area are analyzed result sheet (execution unit) 10. To the next processing of the array (i).

  In this way, the program analysis unit 2 uses the execution part analysis procedure 63 from the information of the execution part 16 of the program 7 as shown in FIG. 24 (a code in which an instruction is replaced with a specific symbol, which is used by the PAD creation unit 4), a hierarchical level 25, a line number 26, and a coding sentence 27.

  Next, referring to FIG. 9, the input sheet creation unit 3 creates a simulation sheet 11 for testing an external subroutine executed by an input / output file or CALL statement used in the program shown in FIG. The operation of creating the breakpoint sheet 12 shown in FIG. 6, which interrupts execution during the test and controls the test state, will be described.

  As shown in FIG. 9, the input sheet creation unit 3 of this example includes a simulation sheet creation process 64 for testing input / output files used in a program, and a break that interrupts execution during the test and controls the test state. Processing is performed in the order of point sheet creation processing 65 and external subroutine test simulation sheet creation processing 66 executed by the CALL statement, and is divided into a simulation sheet 11 and a breakpoint sheet 12. create.

  In the simulation sheet creation process 64 and the simulation sheet creation process 66 for the test of the external subroutine executed by the CALL statement, the test command file creation unit 6 can easily create the test command file for the simulation sheet 11. As shown in FIG. 5, as shown in FIG. 5, the file or module name 30, representative syntax 31 (external subroutine is a representative example of a CALL statement), simulation classification 32 (setting for file simulation and external subroutine simulation is set), Expands to symbol name 33 (item symbol name of 01 level of argument), level 34, item name 35 (item symbol name), attribute 36, and number of digits 37.

  Also, in the breakpoint sheet creation processing 65, the breakpoint sheet 12 is processed with line numbers 43, 43, as shown in FIG. 6, so that the test command file creation unit 6 can easily create the test command file. It expands to a symbol name 44 (which SECTION is a breakpoint) and output presence / absence 45 (whether or not this breakpoint is output to the test command file is set as YES or NO).

  In the I / O file test simulation sheet creation process 64, specifically, as shown in FIG. 9, first, a space is set in the save FILE logical unit name area to initialize the save FILE logical unit name area. Thereafter, one line is inputted from the analysis result sheet (definition part) 9 shown in detail in FIG. 3, and the following processing is repeated until EOF is obtained.

  That is, it is determined whether or not the FILE logical unit name on the input line matches that set in the save FILE logical unit name area. If not, whether the FILE logical unit name on the input line is a space. If it is determined that there is a space, the next line is input from the analysis result sheet (definition unit) 9 and the process is repeated. If it is not a space, a simulation sheet 11 corresponding to the FILE logical device name is newly added. At the same time, the contents of one line read from the analysis result sheet (definition part) 9 are set and output to the simulation sheet 11 already created.

  Also, if the FILE logical unit name in the input line matches the one set in the save FILE logical unit name area, the simulation sheet 11 already created is read from the analysis result sheet (definition unit) 9 1 Outputs (adds) the contents of the line.

  Also, in the breakpoint sheet creation process 65, one line at a time is input from the analysis result sheet (execution unit) 10 shown in detail in FIG. 4 and is used for testing an external subroutine executed with a CALL statement until EOF is reached. The following processing including the simulation sheet creation processing 66 is repeated.

  That is, it is determined whether or not the input line category exists in the main branch instruction category group. If there is, the content of one line read from the analysis result sheet (execution unit) 10 is broken. A setting output (addition) is made to the point sheet 12.

  Thereafter, as a simulation sheet creation process 66 for testing an external subroutine executed by a CALL statement, first, it is determined whether or not the input line is a CALL statement. If it is not a CALL statement, an analysis result sheet is determined. Returning to the processing for the next line in the (execution unit) 10, if it is a CALL statement, it is determined whether or not a simulation sheet has already been created for the CALL statement.

  If a simulation sheet has already been created, the process returns to the processing for the next line in the analysis result sheet (execution unit) 10. If not created, a new simulation sheet is created for the CALL statement and analyzed. An argument is acquired from the content of one line read from the result sheet (execution unit) 10, information on the argument is acquired from the analysis result sheet (definition unit) 9, and the content of the acquired argument is stored in the created simulation sheet. Set output (append).

  In this way, the input sheet creation unit 3 performs the analysis sheet (definition unit) 9 shown in detail in FIG. 3 and FIG. 4 through the simulation sheet creation processes 64 and 66 and the breakpoint sheet creation process 65. From the analysis result sheet (execution unit) 10 showing details, as shown in FIG. 5, the file or module name 30, representative syntax 31, simulation classification 32, symbol name 33, level 34, item name 35, attribute 36, number of digits The simulation sheet 11 expanded to 37 and the breakpoint sheet 12 expanded to line number 43, symbol name 44, and output presence / absence 45 are generated as shown in FIG.

  Next, processing for generating the PAD 13 shown in detail in FIG. 7 from the analysis result sheet (definition unit) 9 and the analysis result sheet (execution unit) 10 by the PAD creation unit 4 will be described with reference to FIG.

  The PAD shown in FIG. 7 shows an example generated from the analysis result sheet (definition part) shown in detail in FIG. 3 and the analysis result sheet (execution part) shown in detail in FIG. When a PAD symbol cell 58 is clicked by operating an input device such as the above, a comment 59 is displayed.

  In this comment 59, the breakpoint line number 26, category 24, item symbol name 20, attribute 21, and number of digits 22 of the instruction are expanded from the analysis result sheet (definition part) and the analysis result sheet (execution part). .

  Such creation of the cell (58) and the comment (59) is performed as shown in a process 67 in FIG. 10 described below.

  As shown in FIG. 10, the PAD creation unit 4 reads from the analysis result sheet (execution unit) one line at a time until EOF and repeats the following processing. First, the position (cell position) at which a figure is stretched is calculated from the number of read lines and the hierarchical level of the read line, and a specific figure is stretched from the section of the read line at the calculated position (cell position).

  Then, the variable is extracted from the coding statement of the read line, the information of the corresponding variable is acquired from the analysis result sheet (definition part), and the content is embedded in the cell comment from the acquired variable information and the read line information. (Processing 67).

  The PAD shown in detail in FIG. 7 created by the PAD creation unit 4 in this way is the simulation sheet (11) shown in detail in FIG. 5 generated by the input sheet creation unit 3 and the breakpoint shown in detail in FIG. The image is displayed on the display device 1a together with the sheet (12) for use.

  Then, the operator performs an input operation on the simulation sheet (11) and the breakpoint sheet (12) displayed on the display device 1a through the input device while referring to the PAD, and the input result The test command file creation unit 6 generates and outputs a test command file 14 based on the contents according to the above.

  The operator operates the input device 1 and first manually inputs a check ID (check ID of the check list) 38, a value 39, and an output sentence format 40 in the simulation sheet (11) of FIG.

  Note that the output sentence format 40 in the simulation sheet (11) of FIG. 5 is generated by the input sheet creation unit 3 with several sentences (for example, “D: DV only”, “S: SV only”, “ND: DV”). (Unconditional) "," NS: Both DV and SV (Unconditional) ", etc.) are set to prevent erroneous input by the operator.

  In addition, the row insertion 28 and the row deletion 29 in the simulation sheet (11) of FIG. 5 are performed by the operator operating the input device 1 to increase the number of rows in the table (simulation sheet 11) or delete a specific row. Used to do. As a result, the operator can easily edit and create the simulation sheet 11.

  Further, the operator operates the input device 1 to change the line number 49, symbol name 50 (SECTION name), level 51, item name 52 (item symbol name), attribute in the breakpoint sheet (12) in FIG. 53, 54 digits, check ID 55 (check ID of check list), value 56, and output sentence format 57 are manually input.

  The output sentence format 57 in the breakpoint sheet (12) in FIG. 6 is generated by the input sheet creation unit 3 by using several sentences (for example, “D: DV only”, “S: SV only”, “ND: DV (unconditional) "," NS: Both DV and SV (unconditional) ", etc.) are set to prevent erroneous input by the operator.

  In addition, line insertion (41, 46) and line deletion (42, 47) in the breakpoint sheet (12) of FIG. 6 are performed by the operator operating the input device 1 and the table (breakpoint sheet 12). Used to increase lines or delete specific lines. As a result, the operator can easily edit and create the breakpoint sheet 12.

  Furthermore, the attribute change 48 in the breakpoint sheet (12) of FIG. 6 can set the cell attribute of the value 56 by the attribute 53.

  Also, the line number 49, symbol name 50 (SECTION name), level 51, item name 52 (item symbol name), attribute 53, and number of digits 54 in the breakpoint sheet (12) in FIG. 6 are described in detail in FIG. It can be set by using / referring to the PAD 13 indicating. An example of the processing operation of the PAD control unit 5 using such a PAD 13 will be described with reference to FIG.

  As shown in FIG. 12, when a cell is clicked in the PAD 13 shown in FIG. 7 (step 70), the PAD control unit 5 displays a breakpoint setting selection screen 74 shown in detail in FIG. 13 (step 71).

  Then, on this breakpoint setting selection screen 74, the operator (user) operates the input device 1, selects "Cancel" and clicks, and the process ends as it is. However, "Set only breakpoint" is selected. Clicking “OK”, from the cell comment (59), the analysis result sheet (definition part) 9 and the analysis result sheet (execution part) 10, “break point” in the break point sheet (12) shown in FIG. The information regarding “line number”, “symbol name”, and “output presence / absence” is extracted and set in the corresponding column (line number, symbol name, output presence / absence) of “breakpoint” of the breakpoint sheet (12).

  On the breakpoint setting selection screen 74, when the operator (user) operates the input device, selects “Set value / Display value condition setting”, and clicks “OK”, the cell comment (59) and From the analysis result sheet (definition part) 9 and the analysis result sheet (execution part) 10, "line number", "symbol name", and "output presence / absence" in "break point" of the break point sheet (12) shown in FIG. And information on “line number”, “symbol name”, “level”, “item name”, “attribute”, “number of digits” in “Set value / Display value” of the breakpoint sheet (12) Is taken out, and the corresponding column (“line number”) in the “break point” of the break point sheet (12) "Symbol name", "Output presence / absence"), and the corresponding column in "Set value / Display value" ("Line number", "Symbol name", "Level", "Item name", "Attribute", "Number of digits" )).

  Using the breakpoint sheet (12) of FIG. 6 and the simulation sheet (11) of FIG. 5 created as described above, the test command creating unit 6 executes the process shown in FIG. A test command file (14) shown in FIG. 14 is generated.

  In the test command file (14) shown in FIG. 14, the breakpoint test command is obtained from each piece of information (line number 43, symbol name 44, output presence / absence 45) in the “breakpoint” of the breakpoint sheet (12) in FIG. 75 (a command for setting a breakpoint), each information (line number 49, symbol name 50, level 51, item name 52, item name) in “Set value / Display value” of the breakpoint sheet (12) in FIG. Set value / Display value test command 76 from attribute 53, number of digits 54, check ID 55, value 56, output sentence format 57), and file simulation information (file name or module in simulation sheet (11) in FIG. 5) Name 30, representative 5, a file simulation test command 77 is obtained from the sentence 31, the simulation classification 32, the symbol name 33, the level 34, the item name 35, the attribute 36, the number of digits 37, the check ID 38, the value 39, and the output sentence format 40). External subroutine simulation information (file name or module name 30, representative syntax 31, simulation classification 32, symbol name 33, level 34, item name 35, attribute 36, number of digits 37, check ID 38, value 39 in the simulation sheet (11) The test command 78 of the external subroutine simulation is generated from the output sentence format 40) and output as the test command file 14.

  A processing operation for generating such a test command file 14 will be described with reference to FIG. As shown in FIG. 11, the test command file 14 is generated in the order of a program breakpoint and Set value / Display value test command output process 68, a file simulation and an external subroutine simulation output process 69.

  First, it is determined whether or not there is no problem by comparing the row numbers and symbol names of the “break point table” and the “set value / display value table” in the break point sheet (12) of FIG. If there is a problem, a message to that effect is displayed. If there is no problem, a test command statement is created from the “breakpoint table” and “Set value / Display value table”, and a test command file (14) (Step 68), and then the simulation sheets (11) of FIG. 5 are input one sheet at a time, and the following processing is repeated for all sheets.

  In other words, the contents of the input simulation sheet are checked to determine whether or not there are frauds. If there are frauds, a message to that effect is displayed. If there are no frauds, a test command statement is created from the simulation sheet. And output to a test command file (step 69).

  As described above with reference to FIGS. 1 to 14C, in this example, when creating a test command file for a debugger of a source program, lexical analysis and syntax analysis of the source program are performed, and an analysis result table of the definition unit A simulation sheet consisting of a list of items in the analysis result table of the definition unit and a column for inputting setting information for debugging including data values for each item. And generating a breakpoint sheet consisting of a column for inputting debug control information including a list of each instruction in the analysis result table of the execution unit and whether or not a breakpoint needs to be set by the operator for each instruction, The breakpoint sheet and simulation sheet are displayed on the screen, and the breakpoint sheet displayed on the screen is displayed. Information specified by the operator is set for the test sheet and simulation sheet, and a test command file is generated using the breakpoint sheet and simulation sheet in which such operator-specified input information is set. It is characterized by. Furthermore, from the analysis result table of the execution unit, a PAD corresponding to the source program is generated and displayed on the display device, and the execution used to generate the PAD at the location specified by the operator operating the input device in the displayed PAD The information in the analysis result table of the part is read out and displayed at the corresponding location, and the information in the analysis result table of the displayed execution part is set in the breakpoint sheet according to the operation instruction from the operator input device It is characterized by that.

  In this way, in this example, the sheets for extracting the items necessary for creating the test command file in the analysis process of the source program and manually entering the information necessary for the test (simulation sheet, breakpoint sheet) A PAD that assists manual input is created and displayed on the screen. By using this sheet and PAD, the operator manually inputs information necessary for the test and creates a test command file. Anyone can easily create test command files and re-create them when the source program is changed.

  In addition, in this example, the flow of processing is performed by buttons, and the function of inactivating and activating buttons is provided so that the flow of processing can be performed in order, and the operator activates each operation. Easy operation by pressing a button.

  In this example, a simulation sheet and a breakpoint sheet indicating all files and external routines are created and displayed with the contents read from the source program, and values after the test processing are displayed on each sheet. And a column for inputting setting information from the operator necessary for setting the value of the branch process and the like. In particular, by using PAD as an auxiliary function, it is basically possible to create test commands in a form that is as conscious of input as possible in the external specifications of the program itself, and even for beginners who do not know the program content and language. It can be done.

  In this example, the breakpoint sheet can be controlled not to create a standard breakpoint by removing the part that is checked for creating a standard breakpoint. In the simulation sheet, By removing the check to create a file, it is possible to avoid creating unnecessary file simulations when reading and testing an actual file.

  As a result, as with standard test commands, depending on the program, the sentence becomes long and the test command is difficult to see. Since the display is made, it is possible to avoid the problem that the test result is difficult to see.

  In this example, the file name is always displayed on the sheet itself so that the contents of the test can be understood, and when the work is interrupted during the work and then resumed, the operator It is possible to instantly remember under what conditions such a value is set, and mistakes can be minimized.

  In addition, this invention is not limited to the example demonstrated using FIGS. 1-14C, In the range which does not deviate from the summary, various changes are possible. For example, in this example, each process is executed by one computer device, but a configuration may be adopted in which distributed processing is performed by a plurality of computer devices.

  In FIG. 1, the simulation sheet 11 and the breakpoint sheet 12 are stored in a memory (main storage device). The simulation sheet 11 and the breakpoint sheet 12 are stored in an external storage device such as a hard disk or a CD. -It can be reused by recording in a recording medium such as a ROM.

  Further, the computer configuration may be a computer configuration without a keyboard or optical disk drive. In this example, an optical disk is used as a recording medium, but an FD (Flexible Disk) or the like may be used as a recording medium. As for the program installation, the program may be downloaded and installed via a network via a communication device.

It is a block diagram which shows the structural example of the test command file creation system which concerns on this invention. It is explanatory drawing which shows the 1st specific example of the program source in FIG. It is explanatory drawing which shows the 2nd specific example of the program source in FIG. It is explanatory drawing which shows the specific example of the analysis result sheet | seat (definition part) in FIG. It is explanatory drawing which shows the specific example of the analysis result sheet | seat (execution part) in FIG. It is explanatory drawing which shows the specific example of the sheet | seat for simulation in FIG. It is explanatory drawing which shows the specific example of the sheet | seat for breakpoints in FIG. It is explanatory drawing which shows the specific example of PAD produced in the PAD production part in FIG. 2 is a flowchart showing a first processing operation example according to the present invention of the test command file creation system in FIG. 1. It is a flowchart which shows the 2nd processing operation example which concerns on this invention of the test command file creation system in FIG. 6 is a flowchart showing a third processing operation example according to the present invention of the test command file creation system in FIG. 1. 7 is a flowchart showing a fourth processing operation example according to the present invention of the test command file creation system in FIG. 1. 7 is a flowchart showing a fifth processing operation example according to the present invention of the test command file creation system in FIG. 1. It is explanatory drawing which shows the example of an operation screen for a breakpoint setting selection. It is explanatory drawing which shows the 1st specific example of the test command file which the test command file creation system in FIG. 1 produced. It is explanatory drawing which shows the 2nd specific example of the test command file which the test command file creation system in FIG. 1 produced. It is explanatory drawing which shows the 3rd specific example of the test command file which the test command file creation system in FIG. 1 produced.

Explanation of symbols

  1: input device, 1a: display device, 2: program analysis unit, 2a: program control unit, 3: input sheet creation unit, 4: PAD creation unit, 5: PAD control unit, 6: test command file creation unit, 7 : Program source, 8: Copy phrase, 9: Analysis result sheet (definition part), 10: Analysis result sheet (execution part), 11: Simulation sheet, 12: Breakpoint sheet, 13: PAD, 14: Test command File: 15: Variable part, 16: Execution part, 17: FILE logical unit name, 18: Structure symbol name, 19: Level, 20: Item symbol name, 21: Attribute, 22: Number of digits, 23: SECTION name, 24: Division, 25: Hierarchy level, 26: Line number, 27: Coding sentence, 28: Insert line, 29: Delete line, 30: File or module name, 31: Table syntax, 32: simulation classification, 33: symbol name, 34: level, 35: item name, 36: attribute, 37: number of digits, 38: check ID, 39: value, 40: output sentence format, 41: line insertion 42: line deletion, 43: line number, 44: symbol name, 45: output presence, 46: line insertion, 47: line deletion, 48: attribute change, 49: line number, 50: symbol name, 51: level, 52: Item name, 53: Attribute, 54: Number of digits, 55: Check ID, 56: Value, 57: Output sentence format, 58: Cell, 59: Comment, 60: Procedure for fetching all lines of a program, 61: Line number Renumbering procedure, 62: Definition part analysis procedure, 63: Execution part analysis procedure, 64: Simulation sheet creation process 64, 65: Breakpoint sheet creation process, 66: External subroutine executed by CALL statement Process for creating a test simulation sheet, 67: Process (cell and comment creation process), 68: Program breakpoint and Set value / Display value test command output process, 69: File simulation and external subroutine simulation output Process: 74: Breakpoint setting selection screen, 75: Breakpoint test command, 76: Set value / Display value test command, 77: File simulation test command, 78: External subroutine simulation test command.

Claims (6)

A computer system for creating a test command file for a debugger of a source program described in COBOL,
Perform lexical analysis and syntax analysis of the above source program,
Reads each definition sentence from the definition of the source program, the contents of Turkey Phi clause put in the definition statement read from the copy clause file for each content of the each definition each sentence and each copy clause structure symbol Generate an analysis result table of the definition part in which the name and level, item symbol name, attribute, and number of digits are registered, store it in the storage device, and read out each executable statement in the execution part of the source program. In addition, an analysis means for generating an analysis result table of the execution unit registered by dividing it into a section name and classification, a hierarchy level, a line number, and a coding statement and storing it in a storage device,
Reading the definition part analysis result table from the storage device and registering contents in the definition part analysis result table and a column for inputting data values set for testing by the operator for the definition sentence and the copy phrase A first input sheet generating means for generating a simulation sheet and storing it in a storage device;
The analysis result table of the execution unit is read from the storage device, each instruction is sequentially extracted from the analysis result table of the execution unit, the list of each extracted instruction, and the test with the instruction as a breakpoint for each instruction A second input sheet generating means for generating a breakpoint sheet including an input field for an operator to set whether to output to a command file and storing the sheet in a storage device;
Display means for reading out the breakpoint sheet generated by the second input sheet generating means and the simulation sheet generated by the first input sheet generating means from the storage device and displaying them on the screen;
An input means for setting information designated and input by the operator for each input field in the breakpoint sheet and the simulation sheet displayed on the screen,
A test command file creation system characterized in that the input means has command creation means for generating and outputting a test command file using a breakpoint sheet and a simulation sheet in which designated input information from an operator is set . The test command file creation system according to claim 1,
An analysis result table of the definition unit and an analysis result table of the execution unit are read from a storage device, and a PAD corresponding to the source program is generated from the analysis result table of the definition unit and the analysis result table of the execution unit and displayed. Means for outputting and displaying
In the PAD displayed on the display device, the line number, category, item symbol name, and attribute in the analysis result table of the above definition part and the analysis result table of the execution part used for PAD generation at the location specified by the operator operating the input device , Means for reading out information including the number of digits and displaying the information at the location;
And means for setting information including the displayed line number, category, item symbol name, attribute, and number of digits in the breakpoint sheet in accordance with an operation instruction from an operator input device. Test command file creation system. A test command file creation method for creating a test command file for a debugger of a source program from a source program described in COBOL by a computer ,
The computer includes an analysis unit and a first input sheet generation unit, a second input sheet generation unit, a display unit, an input unit, and a command generation unit as a unit for executing programmed computer processing.
By the above analysis means,
Performs lexical analysis and syntax analysis of the source program, reads each definition sentence from the definition of the source program, reads the contents of Turkey Phi clause put in the definition statement from the copy clause Fiaru, each defined each sentence and For each content of each copy phrase, an analysis result table of a definition part in which structure symbol names and levels, item symbol names, attributes, and the number of digits are registered is generated and stored in a storage device, and the source program is executed. The first execution statement is read out, and an analysis result table of the execution unit registered for each execution statement divided into section name and division, hierarchy level, line number, and coding statement is generated and stored in the storage device. procedure is executed,
By the first input sheet generating means,
Reading the definition part analysis result table from the storage device and registering contents in the definition part analysis result table and a column for inputting data values set for testing by the operator for the definition sentence and the copy phrase A second procedure of generating a simulation sheet and storing it in a storage device,
By the second input sheet generating means,
The analysis result table of the execution unit is read from the storage device, each instruction is sequentially extracted from the analysis result table of the execution unit, a list of each extracted instruction, and the instruction is a breakpoint for each instruction. A third step of generating a breakpoint sheet including an input field set by the operator as to whether or not to output the test command file and storing the sheet in the storage device;
By the display means,
Executing the fourth procedure of reading the breakpoint sheet generated in the third procedure and the simulation sheet generated in the second procedure from the storage device and displaying them on the screen;
By the above input means,
Execute a fifth procedure for setting information designated and input by the operator for each entry field in the breakpoint sheet and simulation sheet displayed on the screen,
By the above command creation means,
A sixth procedure for generating and outputting a test command file using the breakpoint sheet and the simulation sheet in which designated input information from the operator is set in the fifth procedure is executed. How to create a test command file. A test command file creation method according to claim 3,
The computer includes a PAD creation means and a PAD control means as means for executing programmed computer processing,
By the PAD creation means,
An analysis result table of the definition unit and an analysis result table of the execution unit are read from a storage device, and a PAD corresponding to the source program is generated from the analysis result table of the definition unit and the analysis result table of the execution unit and displayed. Follow the steps to print and display
By the PAD control means,
In the PAD displayed on the display device, the line number, classification, item symbol name in the analysis result table of the definition unit and the analysis result table of the execution unit used for generating the PAD of the place specified by the operator operating the input device, Execute the procedure to read the information including the attribute and the number of digits and display it in the relevant place,
By the PAD creation means,
A procedure for setting information including the displayed line number, category, item symbol name, attribute, and number of digits in the breakpoint sheet in accordance with an operation instruction from the operator's input device is executed. A test command file creation method characterized by the above. A program for causing a computer to execute the following procedures to create a test command file for a debugger of the source program from the source program described in COBOL.
Performs lexical analysis and syntax analysis of the source program, reads each definition sentence from the definition part of the source program, reads the contents of the copy phrase in the definition sentence from the copy phrase file, and for each definition sentence and each copy For each phrase content, generate an analysis result table of the definition part in which the structure symbol name and level, item symbol name, attribute, and number of digits are registered, store it in the storage device, and each in the execution part of the source program A first procedure of reading an executable statement, generating an analysis result table of the execution unit registered separately for each executable statement by section name and division, hierarchy level, line number, and coding statement, and storing them in a storage device;
Reading the definition part analysis result table from the storage device and registering contents in the definition part analysis result table and a column for inputting data values set for testing by the operator for the definition sentence and the copy phrase A second procedure for generating a simulation sheet and storing it in a storage device;
The analysis result table of the execution unit is read from the storage device, each instruction is sequentially extracted from the analysis result table of the execution unit, a list of each extracted instruction, and the instruction is a breakpoint for each instruction. A third procedure for generating a breakpoint sheet including an input field for an operator to set whether to output to a test command file and storing it in a storage device;
A fourth procedure in which the breakpoint sheet generated in the third procedure and the simulation sheet generated in the second procedure are read from the storage device and displayed on the screen;
A fifth procedure for setting information designated and input by the operator for each input field in the breakpoint sheet and the simulation sheet displayed on the screen;
A sixth procedure for generating and outputting a test command file using the breakpoint sheet and the simulation sheet in which the designated input information from the operator is set in the fifth procedure. The program according to claim 5, which causes a computer to execute the following procedures.
An analysis result table of the definition unit and an analysis result table of the execution unit are read from a storage device, and a PAD corresponding to the source program is generated from the analysis result table of the definition unit and the analysis result table of the execution unit and displayed. To output and display
In the PAD displayed on the display device, the line number, classification, item symbol name in the analysis result table of the definition unit and the analysis result table of the execution unit used for PAD generation at the location specified by the operator operating the input device, A procedure for reading out information including the attribute and the number of digits and displaying it in the relevant place,
A procedure for setting information including the displayed line number, category, item symbol name, attribute, and number of digits in the breakpoint sheet in accordance with an operation instruction from the operator's input device.

Images