JPH0934750A - System for generating source program for test - Google Patents

Abstract

PROBLEM TO BE SOLVED: To prepare a source program for test with less artificial error to the utmost. SOLUTION: This system is provided with a source program storage means 101 for storing a source program D1 as a test object, test execution procedure definition storage means 102 for storing a test execution procedure definition D4 for defining a debugging sentence to be inserted to the source program and the position of insertion so that the propriety of the executed result can be discriminated by executing the stored source program as a test, and converting means 103 for extracting the stored test execution procedure definition and converting it to the debugging sentence described in a program language suitable for the source program. Further, a source program generating means 104 for test is provided for generating the source program for test by extracting the stored source program and inserting the converted test execution procedure definition at a designated position.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a test source program generation system, and particularly when a source program used in an information processing system is tested, a test in which information for determining pass / fail of a test result is inserted into the source program. The present invention relates to a test source program generation system for automatically generating a test source program.

In the process of creating a source program,
It is necessary to execute a test to confirm whether the source program being created operates normally. However, the output information (hereinafter referred to as debug statement) peculiar to the test, which displays the quality of the operation result, is used as the target of the test. If it is not added to the source program, it will be difficult to judge the quality.

Therefore, when creating and testing a source program, it is necessary to create a test source program to which the procedure of the above-mentioned debug statement is added.

[0004]

2. Description of the Related Art FIGS. 8 and 9 are diagrams illustrating a conventional method of creating a test source program.

8 and 9, in FIG. 8 (a),
"Call of function subr" of source program (D ₁ )
The procedure for is shown. The test executor who tests the procedure related to "call of function subr" of the source program (D ₁ ) needs to create a test item / test procedure document (D ₂ ) as shown in FIG. 8 (b). .

The test item / test procedure (D ₂ ) is shown in FIG.
As shown in (b), it is necessary to describe the test item name, environment definition part, and confirmation procedure definition part. In the test item name, "call of function subr" is described.

In the environment definition section, the test input data "a =
1, b = 2 ”and the insertion location“ LO-= (1) ”are described. In the confirmation procedure definition section, the test content “if the value of the variable c is 3, confirm that the function subr is called”, the precondition “c is 3”, and the confirmation location “LO2-if (1 ) +2 "is described.

Next, the test executor writes the designated debug statement in the programming language used for the source program (D ₁ ) to be tested according to the test item / test procedure manual (D ₂ ). , A test source program (D ₃ ) as shown in FIG. 9 (c) is created by inserting the test program into the designated location of the source program (D ₁ ).

Test source program (D_Three) Is
Source program (D₁) Of the specified block "LO
1 line before, the test input data “a = 1, b = 2”
Two lines of the reserved word "if" that has been inserted and is specified
Later, the source program (D ₁) Programming language
The described debug statement "If the value of the variable c is 3, the function su
"call br" is inserted.

[0010] The test run shall, by running test for the source program (D ₃₎ in the information processing apparatus, to verify the quality of the test item in the source program (D ₁₎ "function call subr".

[0011]

As is apparent from the above description, in the conventional method of creating a test source program, the test executor prepares in advance the source program (D ₁ ) to be tested and the source program to be tested. Based on the test item / test procedure (D ₂ ), test source program (D ₃ ).
Since it was created by hand, there was a problem that human error was likely to occur.

An object of the present invention is to make it possible to create a test source program with a minimum of human error.

[0013]

FIG. 1 is a diagram illustrating the principle of the present invention. In FIG. 1, 101 is a source program storage means provided in the test source program generation system according to the present invention.

Reference numeral 102 denotes a test execution procedure definition storage means provided in the test source program generation system according to the present invention. Reference numeral 103 is a conversion unit provided in the test source program generation system according to the present invention.

Reference numeral 104 is a test source program generation means provided in the test source program generation system according to the present invention.

[0016]

The source program storage means (101) stores the source program (D ₁ ) to be tested.

The test execution procedure definition storage means (102) is
A debug statement to be inserted into the source program (D ₁ ) and a debug statement in order to execute the source program (D ₁ ) stored in the source program storage means (101) on a trial basis and determine the quality of the execution result. The test execution procedure definition (D ₄ ) that defines the insertion location of the sentence is stored.

The conversion means (103) extracts the test execution procedure definition (D ₄ ) from the test execution procedure definition storage means (102) and converts it into a debug statement written in a programming language suitable for the source program (D ₁ ). To do.

Test source program generation means (10
4) extracts the source program (D ₁ ) from the source program storage means (101), and converts the converted test execution procedure definition (D ₄ ) output from the conversion means (103) into the test execution procedure definition (D Insert it in the location specified in ₄ ) and generate the test source program (D ₃ ).

The conversion means (103) has a function of converting the test execution procedure definition (D ₄ ) into a plurality of programming languages, and the test source program generation means (10).
It is considered to output the test execution procedure definition (D ₄ ) converted from 4) into the designated programming language.

A test source program generating means (1
04) is the test execution sequence definition (D _4), at a location specified by the absolute line number of the source program (D _1), or within a particular constituted source program (D ₁₎ from a plurality of partial source program It is specified at the position specified by the information specifying the partial program and the relative line number in the specific partial program, and further by the appearance order of the reserved words defined for each program language of the source program (D ₁ ). It is considered to insert the test execution procedure definition (D ₄ ) in the place.

A test source program generating means (1
04) holds the conversion rules corresponding to the definition symbols constituting the test execution procedure definition (D ₄ ), and the test execution procedure definition (D ₄ ).
It is considered that ₄ ) is converted into a debug statement in units of definition symbols and edited.

A test source program generating means (1
04) is a source program (D ₁₎ and test execution procedure definition (D ₄₎ is the case that has been divided into a version number of a plurality of types, respectively, a source program (D ₁₎ and applied to test execution procedure definition (D ₄ ) Is considered to be managed according to each version number.

A test source program generating means (1
04) is a source program (D ₁₎ to the test execution procedure definition (D ₄₎ of the insert and test results Test execution procedure definition becomes defective parts of (D _4), re-test execution procedure definition (D _A ) Is considered.

Therefore, since the test source program is automatically generated by preparing the source program and the test execution procedure definition, the chance of human error is greatly reduced, and the test of the source program is performed. It is possible to improve the efficiency of the work, that is, the work of creating the source program.

[0026]

An embodiment of the present invention will be described below with reference to the drawings. 2 is a diagram showing a test source program generation system according to an embodiment of the present invention, FIG. 3 is a diagram showing an example of the test source program generation unit in FIG. 2, and FIG. 4 is a diagram showing the editing unit in FIG. 5 is a diagram illustrating an example of a test source program generation process in FIG. 2, FIG. 6 is a diagram illustrating an edit process in FIG. 4, and FIG. 7 is a version number management process in FIG. It is a figure which illustrates. The same reference numerals indicate the same objects throughout the drawings.

In FIG. 2, a test source program generation system according to an embodiment of the present invention comprises a central processing unit (1 _C ), a main memory (1 _M ), a non-volatile memory (2) and a volatile memory. It is built on an information processing system consisting of a device (3), a display ( _4D ), a keyboard ( _4K ) and an input / output control device (5).

A test source program generator (1) is provided on the central processing unit (1 _C ) and the main memory (1 _M ).
1), editing unit (12), retest execution procedure output unit (1
3), a version number management unit (14) and a screen display unit (15) are provided.

Each of the above units (11 to 15) is constructed by the central processing unit (1 _C ) executing a program stored in the main memory (1 _M ).

In FIG. 2, the non-volatile memory device (2) is the source program storage means (1) shown in FIG.
01) and the test execution procedure definition storing means (102), and also the editing unit (12) in the central processing unit (1 _C ) and the main memory (1 _M ) and the nonvolatile memory (2). Conversion rules (D ₅ ) and volatile storage (3)
The conversion rule table (D ₈ ) in FIG. 1 serves as the conversion means (103) in FIG. 1, and the central processing unit (1 _C )
The test source program generation unit (11) in the main memory (1 _M ) serves as the test source program generation means (104) in FIG.

Test source program generator (11)
As shown in FIG. 3, the source program extraction unit (1
11), test execution procedure definition analysis unit (112), conversion rule definition analysis unit (113), test execution procedure definition table search unit (1)
14) and a conversion rule retrieval unit (115), and the editing unit (12) includes a test execution procedure definition analysis unit (121), a conversion rule analysis unit (122), and a test execution procedure as shown in FIG. Definition display section (123), conversion rule display section (1
24) and an edited result storage unit (125).

2 to 7, in the non-volatile memory device (2), a source program (D ₁ ) to be tested and a test execution procedure definition (D ₄ ) created by a test executor, The conversion rules (D ₅ ) created by a plurality of types of programming languages are stored in advance.

When the editing unit (12) is activated in such a state, the conversion rule analysis unit (122) extracts the conversion rule (D ₅ ) from the non-volatile storage device (2), and each definition symbol (D ₅ ).
_5A ) and the corresponding conversion rule (D _5B ) are stored in the volatile storage device (3).

In FIG. 6, the definition symbol (D _5A1 ) =
The conversion rule (D _5B1 ) = “printf (“ [A] =% d ¥ ”corresponding to“ when the value of variable [A] is [B]: ”]
n ", [A]);" is stored, also calls the definition symbol (D _5A2) = "function (X):" in response to a conversion rule (D _5B2) = "printf (" call [X]
\ N ");" is stored.

Next, the test execution procedure definition analysis unit (121)
Is the test execution procedure definition (D
₄ ) is extracted, and each test item (D ₄₁ ) and the corresponding confirmation procedure definition (test content (D ₄₂ )) are stored in the volatile storage device (3).

The test execution procedure definition analysis unit (121)
Searches the stored confirmation procedure definition (test content (D ₄₂ )) using the definition symbol (D _5A ) stored in the volatile storage device (3) as a keyword, and confirms that the same definition symbol (D _5A ) is included. When the procedure definition (test content (D ₄₂ )) is detected, the corresponding confirmation procedure definition (test content (D ₄₂ )) and the definition symbol (D _5A ) are associated with each other by link information.

In FIG. 6, the test content (D ₄₂₁ ) corresponds to the test item (D ₄₁ ) = “call of function subr”.
= “When the value of variable c is 3”, the test content (D ₄₂₂ ) =
“Call function subr” is stored, and the test content (D ₄₂₁ ) = “when the value of variable c is 3” and the definition symbol (D
_5A1) = "if the value of the variable [A] is [B]:" and the test contents (D ₄₂₂₎ = Definition designated 'calls the function subr "(D _5A2) =" calls the function (X): " And are respectively linked by the link information.

Next, the conversion rule display unit (124) extracts the conversion rule (D ₅ ) stored by the conversion rule analysis unit (122) from the volatile storage device (3) and displays it on the display (4 _D ). The test execution procedure definition display section (123) extracts the test execution procedure definition (D ₄ ) stored by the test execution procedure definition analysis section (121) from the volatile storage device (3) and displays it (4 _D ). [See FIG. 6], and the edit result storage unit (125) displays the conversion rule (D ₅ ) and the test execution procedure definition (D ₄ ) displayed on the display (4 _D ).
Are stored in the volatile storage device (3).

The test executor observes the conversion rule (D ₅ ) and the test execution procedure definition (D ₄ ) displayed on the display (4 _D ) and operates the keyboard (4 _K ) as necessary. Perform editing work.

In the editing work, when the test executor specifies, for example, the test content (D ₄₂₁ ) = “when the value of the variable c is 3”, the test execution procedure definition display section (123) and the conversion rule display section (124) Highlights the definition symbol (D _5A1 ) = “when the value of the variable [A] is [B]:” associated with the designated test content (D ₄₂₁ ) by the link information.

When the test executor executes a predetermined edit work completion operation after executing the required edit work, the edit result storage section (125) stores the stored pre-edit conversion rule (D ₅ ) and the test execution procedure. The definition (D ₄ ) is updated to the conversion rule (D ₅ ) at the editing completion stage and the test execution procedure definition (D ₄ ), and the conversion rule (D ₅ ) in the non-volatile storage device (2) is also updated.
In addition, the relevant update processing is added to the test execution procedure definition (D ₄ ).

When the test source program generation unit (11) is started after the conversion rule (D ₅ ) and the test execution procedure definition (D ₄ ) are edited, the test execution procedure definition analysis unit (112) The test execution procedure definition (D ₄ ) is extracted from the non-volatile storage device (2), and the test execution procedure definition table (D
₇ ) is stored in the volatile storage device (3) [step S51 in FIG. 5].

Next, the conversion rule definition analysis unit (113) extracts the conversion rule (D ₅ ) from the non-volatile storage device (2),
The conversion rule table (D ₈ ) is stored in the volatile storage device (3) [step S52].

Next, the source program extraction unit (111)
Extracts the source program (D ₁ ) to be tested from the non-volatile memory device (2) for one line, stores it as source program information (D ₆ ) in the volatile memory device (3), and defines the test execution procedure. The table search unit (114) is activated [step S53].

The test execution procedure definition table search unit (1
14) searches the test execution procedure definition table (D ₇ ) stored in the volatile storage device (3) based on the source program information (D ₆ ) stored in the volatile storage device (3), and applies When the definition symbol (D _5A ) [and conversion rule (D _5B )] is detected, it is stored in the volatile storage device (3) as the relevant test execution procedure definition (D ₉ ) and then the conversion rule retrieval unit (11).
5) Start.

The activated conversion rule retrieval unit (115)
By referring to the conversion rule table (D ₈ ) stored in the volatile storage device (3), the definition symbol (D _5A ) corresponding to the relevant test execution procedure definition (D ₉ ) stored in the volatile storage device (3) ) And conversion rule (D _5B ) according to the applicable test execution procedure definition (D ₉ )
It was converted to the debug Bunkeishiki [step S56], and outputs the test source program (D ₃₎ [step S5
7].

Further, the test execution procedure definition table retrieval unit (11
4) is the result of searching the test execution procedure definition table (D ₇ ),
Applicable definition symbol (D _5A ) [and conversion rule (D _5B )]
If no is detected, the source program information (D ₆ ) is output to the normal test source program (D ₃ ) [step S57].

The test source program generator (1
When the type of the programming language used for the source program (D ₁ ) to be tested is specified at the stage of activating 1), the conversion rule definition analysis unit (113) causes the conversion rule (D) prepared for each programming language. _The designated conversion rule (D ₅ ) is selected from among ₅ ) and a debug statement in the corresponding programming language is generated.

The test source program generator (1
At the stage of starting 1), the test items (D
_{When the} test execution procedure definition (D ₄ ) including ₄₁ ) is specified, the specified test execution procedure definition (D ₄ ) [that is, the test item (D
₄₁ )] only the debug statement is output to the test source program (D ₃ ).

The test source program (D ₃ ) generated in this manner is executed by the information processing system, and the obtained execution result (D _B ) is used as the retest execution procedure output unit (1
3), the retest execution procedure output unit (13)
The information for judging the quality of the execution result (D _B ) of each test item (D ₄₁ ) is extracted, and the test execution procedure definition (D ₄ ) is extracted from the nonvolatile storage device (2), and the execution result (D _B ) is extracted. ), The test execution procedure definition (D ₄ ) related to the test item (D ₄₁ ) determined to be defective in the execution result (D _B )
Output only as the retest execution procedure definition (D _A ).

Further, FIG. 7 shows a source program to be tested.
(D₁) And the test execution procedure definition (D _Four) And version management
Although it is a diagram showing the reason, the result of the test is that the
Source program (D₁) When you make a correction
If it is an additional correction, the test execution procedure definition (D_Four)
Source program (D₁) Test items for the modified parts
Will need to be added.

In this case, the version number management unit (14) adds the version numbers (V.1 to V.n) assigned to the source program (D ₁ ) and the test execution procedure definition (D ₄ ). It is possible to extract the test execution procedure definition (D ₄ ) corresponding to the version number of the source program (D ₁ ) by managing it in correspondence with the version number information (W.1 to W.m) that is stored. Becomes

As is clear from the above description, according to this embodiment, the source program (D ₁ ) to be tested,
When the test execution procedure definition (D ₄ ) created by the test executor is input to the test source program generation system, the debug statement specified by the test execution procedure definition (D ₄ ) is added to the source program (D ₁ ). Since the test source program (D ₃ ) is automatically generated, there is no risk of human error, the judgment result of the quality of the test execution can be visually recognized, and the retest execution procedure manual is available. Since it is automatically created, the test confirmation work becomes easy.

2 to 9 are merely embodiments of the present invention, and, for example, the target source program (D
₁ ), the test execution procedure definition (D ₄ ) and the test source program (D ₃ ) are not limited to those shown in the figure, and many other variations may be considered. The effect of the invention does not change. It goes without saying that the information processing system in which the test source program generation system is constructed is not limited to that shown in the figure.

[0055]

As described above, according to the present invention, since the test source program is automatically generated by preparing the source program and the test execution procedure definition, the chance of human error is greatly increased. It is possible to improve the efficiency of the test work of the source program, and eventually the work of creating the source program.

[Brief description of drawings]

FIG. 1 is a principle diagram of the present invention.

FIG. 2 is a test source program generation system according to an embodiment of the present invention.

FIG. 3 is a test source program generation unit in FIG.

FIG. 4 is an editing unit in FIG.

FIG. 5 is a test source program generation process in FIG.

FIG. 6 is an editing process in FIG.

FIG. 7 is a version number management process in FIG.

FIG. 8 is a conventional method for creating a test source program (No. 1)

FIG. 9: Method for Creating Conventional Test Source Program (Part 2)

[Explanation of symbols]

1 _C Central processing unit 1 _M Main storage device 2 Non-volatile storage device 3 Volatile storage device 4 _D display 4 _K keyboard 5 Input / output control device 11 Test source program generation unit 12 Editing unit 13 Retest execution procedure output unit 14 version Number management unit 15 Screen display unit 101 Source program storage unit 102 Test execution procedure definition storage unit 103 Conversion unit 104 Test source program generation unit 111 Source program extraction unit 112 Test execution procedure definition analysis unit 113 Conversion rule definition analysis unit 114 Test execution Procedure definition table search unit 115 Conversion rule search unit 121 Test execution procedure definition analysis unit 122 Conversion rule analysis unit 123 Test execution procedure definition display unit 124 Conversion rule display unit 125 Edit result storage unit

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Noritoshi Kobayashi 1015 Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa, Fujitsu Kansai Communication Systems Co., Ltd. Kansai Communication Systems Co., Ltd. (72) Inventor Keiko Ojima 1015 Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa Fujitsu Kansai Communication Systems Co., Ltd.

Claims (6)

[Claims] 1. A source program storage unit for storing a source program to be tested, and a source program stored in the source program storage unit for trial execution to determine whether the execution result is good or bad. A debug statement to be inserted into the source program, and a test execution procedure definition storage unit for storing a test execution procedure definition defining an insertion point of the debug statement; and a test execution procedure definition from the test execution procedure definition storage unit. Conversion means for extracting and converting to a debug statement written in a programming language suitable for the source program, and a converted test execution procedure definition extracted from the source program storage means and output from the conversion means At the location specified in the test execution procedure definition to generate the test source program. And a test source program generating means for generating the test source program. 2. The conversion means has a function of converting the test execution procedure definition into a plurality of types of programming languages,
The test source program generation system according to claim 1, wherein the test source program generation means outputs the test execution procedure definition converted into a designated program language. 3. The test source program generation means is arranged in the test execution procedure definition, at a location designated by an absolute line number of the source program, or in the source program composed of a plurality of partial source programs. In the location designated by the information designating the specific partial program and the relative line number in the specific partial program,
Furthermore, at the location specified by the order of appearance of reserved words defined for each programming language of the source program,
The test source program generation system according to claim 1, wherein the test execution procedure definition is inserted. 4. The test source program generation means holds a conversion rule corresponding to a definition symbol constituting the test execution procedure definition, converts the test execution procedure definition into a debug statement in definition symbol units, and edits the statement. The test source program generation system according to claim 1, wherein 5. The test source program generation means, when the source program and the test execution procedure definition are respectively divided into a plurality of types of versions, respectively, the source program and the test execution procedure definition to be applied, respectively. The test source program generation system according to claim 1, wherein the test source program generation system is managed in correspondence with each version number. 6. The test source program generating means inserts the test execution procedure definition into the source program and outputs a portion of the test execution procedure definition having a bad test result as a retest execution procedure definition. The test source program generation system according to claim 1, wherein