JP4966386B2 - Test item generation method, apparatus and program - Google Patents

Description

  The present invention relates to a test item generation method, apparatus, and program, and more particularly, to a test item generation method, apparatus, and program for generating a test item when performing an integration test using software design information.

  Conventionally, as a first technique for generating test items for integration tests using software design information, UML (Unified Modeling Language) activity diagrams and class diagrams are used as inputs, and test paths and test data are used as test items. There is a method of outputting (see, for example, Non-Patent Document 1).

  Further, as a second technique, there is a method of inputting a class diagram and a state chart diagram (corresponding to a screen transition diagram) and outputting a screen transition route as a test item (for example, see Patent Document 1).

JP 2007-94453 A

Akira Zhang, Takashi Hoshino, "Test Item Extraction and Test Data Generation Method Using Design Model", IEICE Technical Report. KBSE, Intelligent Software Engineering, Technical report of IEICE KBSE 109 (41) pp.37-42, 20090514.

  However, the above first conventional technique cannot handle screen transition diagrams, screen element definition documents, process event definition documents, input constraint definition documents, etc., and therefore has a problem that the types of test items to be output are not sufficient. .

  In addition, since the second conventional technique cannot handle a process event definition document, an input constraint definition document, a process overview flow, and the like, there is a problem that the types of test items to be output are not sufficient as described above. .

  The present invention has been made in view of the above points, and as a type of design document that can be input for test generation, in addition to the conventional screen transition diagram and process overview flowchart, a screen element definition document and a process event definition Test items that can be entered automatically and automatically generated as test items that can be generated automatically, including the behavior of conventional processing, whether there are DB changes, whether there are input errors, and how to output results It is an object of the present invention to provide a test item generation method, apparatus, and program that can be output.

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

The present invention (Claim 1) is a test item generation device for generating a test item when performing an integration test using software design information,
Screen transition diagram showing transitions between screens in the function, screen element definition document describing definitions related to input / output and attributes for each component in the screen, input that is a restriction on the screen element alone Document memory that stores a constraint definition document, a process event definition document that describes state transitions caused by events that occurred on the screen, and a process overview flow definition document that describes the process flow for clarifying the behavior of the process Means 101;
Intermediate language storage means 102 for storing an object converted from a document into an intermediate language;
Design model storage means 103 for storing the generated design model;
Test item storage means 104 for storing the extracted test items;
A document reading means 110 that reads each document group from the document storage means 101 and stores an object converted into a single intermediate language into the intermediate language storage means 102;
A design model generation unit 120 that integrates objects converted from the intermediate language storage unit 102 into an intermediate format language into a single design model and stores the design model storage unit 103;
A test item extracting unit that acquires a design model from the design model storage unit 103, extracts the presence / absence of an input error, a test path, the presence / absence of a DB change, and a result output method as test items, and stores the test items in the test item storage unit 104 130,
And an output unit 140 that reads out test items from the test item storage unit 104, forms them into a predetermined form format, and outputs them.

Further, the present invention (Claim 2) is the document reading means 110 of Claim 1,
Based on the specified file path, the screen transition diagram is read from the document storage means, the corresponding intermediate language screen transition diagram object is generated, and the intermediate language screen object corresponding to each screen of the screen transition diagram is generated. , Store the list linked with the screen transition diagram object in the intermediate language storage means,
Based on the screen ID of the screen transition diagram, the screen element definition document is read from the document storage unit 101, a corresponding intermediate language screen element object is generated, and a list linked to the screen object is stored in the intermediate language storage unit 102. ,
Based on the screen ID of the screen element definition document, the input constraint definition document is read from the document storage unit 101, a corresponding intermediate language input constraint object is generated, and the list linked to the screen element object is stored in the intermediate language storage unit 102. Store and
Based on the screen ID of the screen element definition document, the process event definition document is read from the document storage unit 101, a corresponding intermediate language process event object is generated, and a list linked to the screen element object is stored in the intermediate language storage unit 102. Store and
Based on the screen ID of the process event definition document, the process outline flow diagram is read from the document storage unit 101, a process outline flow object corresponding to the intermediate language is generated, and the list linked with the process event object is stored in the intermediate language storage unit 102. Including means for storing in
The design model generation means 120
A list in which the objects are linked is read from the intermediate language storage unit 102,
A screen element object linked to a screen object is converted into a predetermined unified format using a unified formatting tool,
Convert the processing event object linked to the screen object into a predetermined unified format using the unified formatting tool,
The input constraint object linked to the screen element object and the process overview flow object linked to the process event object are merged to generate an overall flow object, and the overall flow object is set to a predetermined format using a unified format tool. The data is converted into a unified format and stored in the design model storage unit 103.

Further, the present invention (Claim 3) provides the document storage means 101 of Claim 1 or Claim 2 described above.
Instead of screen transition diagram, store screen list,
The document reading means 110
Means for generating an intermediate language screen object corresponding to each screen of the screen list and storing the list linked with the screen transition diagram object in the intermediate language storage means;

Further, the present invention (Claim 4) is the test item extraction means 130 according to Claims 1 to 3,
The design model is read from the design model storage means 103, the execution path to be tested is extracted from the entire flow object converted into a predetermined unified format, the test path and input errors are detected from the execution path, and the DB is changed The method includes extracting a result output method as a test item, grouping them as a single test item, generating a test item table, assigning a processing event name, and storing it in the test item storage unit 104.

  FIG. 2 is a diagram for explaining the principle of the present invention.

The present invention (Claim 5) is a test item generation method for generating a test item when performing an integration test using software design information,
Screen transition diagram showing transitions between screens in the function, screen element definition document describing definitions related to input / output and attributes for each component in the screen, input that is a restriction on the screen element alone Document memory that stores a constraint definition document, a process event definition document that describes state transitions caused by events that occurred on the screen, and a process overview flow definition document that describes the process flow for clarifying the behavior of the process Means,
Intermediate language storage means for storing objects converted from a document into an intermediate language;
Design model storage means for storing the generated design model;
Test item storage means for storing the extracted test items;
In a device having
A document reading step (step 1) for reading each document group from the document storage means and storing the object converted into a single intermediate language into the intermediate language storage means;
A design model generation step (step 2) in which objects converted from the intermediate language storage means into an intermediate language are integrated into a single design model and stored in the design model storage means (step 2);
A design model is acquired from the design model storage means, the presence / absence of an input error, a test path, the presence / absence of a DB change, and a result output method are extracted as test items, and a test item storage step (step 3);
An output step (step 4) of reading the test item from the test item storage means, forming it into a predetermined form format, and outputting it is performed.

According to the present invention (Claim 6), in the document reading step of Claim 5,
Based on the specified file path, the screen transition diagram is read from the document storage means, the corresponding intermediate language screen transition diagram object is generated, and the intermediate language screen object corresponding to each screen of the screen transition diagram is generated. , Store the list linked with the screen transition diagram object in the intermediate language storage means,
Based on the screen ID of the screen transition diagram, the screen element definition is read from the document storage means, a corresponding intermediate language screen element object is generated, a list linked with the screen object is stored in the intermediate language storage means,
Based on the screen ID of the screen element definition document, the input constraint definition document is read from the document storage means, the corresponding intermediate language input constraint object is generated, and the list linked with the screen element object is stored in the intermediate language storage means. ,
Based on the screen ID of the screen element definition document, the processing event definition document is read from the document storage means, a corresponding intermediate language processing event object is generated, and a list linked with the screen element object is stored in the intermediate language storage means. ,
Based on the screen ID of the process event definition document, the process overview flow diagram is read from the document storage means, a corresponding process overview flow object of intermediate language is generated, and a list linked to the process event object is stored in the intermediate language storage means Perform the steps to
In the design model generation step,
Read a list of linked objects from the intermediate language storage means,
A screen element object linked to a screen object is converted into a predetermined unified format using a unified formatting tool,
Convert the processing event object linked to the screen object into a predetermined unified format using the unified formatting tool,
The input constraint object linked to the screen element object and the process overview flow object linked to the process event object are merged to generate an overall flow object, and the overall flow object is set to a predetermined format using a unified format tool. A step of converting to a unified format and storing in the design model storage means is performed.

According to the present invention (Claim 7), in the document storage means of Claim 6,
When a screen list is stored instead of a screen transition diagram,
The document loading step
An intermediate language screen object corresponding to each screen of the screen list is generated, and a list linked with the screen transition diagram object is stored in the intermediate language storage means.

Further, the present invention (Claim 8) is the test item extraction step of Claims 5 to 7,
The design model is read from the design model storage means, the execution path to be tested is extracted from the entire flow object converted into a predetermined unified format, the test path and the presence or absence of an input error, the presence or absence of a DB change, The result output method is extracted as test items, these are grouped as one test item, a test item table is generated, a processing event name is given, and the result is stored in the test item storage means.

  The present invention (Claim 9) is a test item generation program for causing a computer to function as each means constituting the test item generation apparatus according to any one of Claims 1 to 4.

  As described above, according to the present invention, a screen transition diagram, a screen element definition document, a process event definition document, and a process overview flow diagram can be converted into an intermediate language, and in addition, a screen instead of a screen transition diagram. It is also possible to use a list. Furthermore, since an input constraint definition document can be input, five types of design documents can be handled as input.

  Also, by integrating individual intermediate format languages corresponding to each design document into one design model (XMI format UML model), it is possible to collect information necessary for test items.

  In addition, it is possible to extract test path, presence / absence of DB change, result output method, etc. as test items from the design model, and also extract presence / absence of input errors, so four types of test items are output. be able to.

It is a principle block diagram of this invention. It is a figure for demonstrating the principle of this invention. It is an example of the input design document (screen transition diagram) in one embodiment of the present invention. It is an example of the input design document (screen element definition document) in one embodiment of this invention. It is an example of the input design document (input constraint definition document) in one embodiment of the present invention. It is an example of the input design document (processing event definition document) in one embodiment of this invention. It is an example of the input design document (process outline | summary flowchart) in one embodiment of this invention. It is a block diagram of the test item generation apparatus in one embodiment of this invention. It is a flowchart of the outline | summary operation | movement in one embodiment of this invention. It is an example of the output document (test item table | surface) in one embodiment of this invention. It is a flowchart (the 1) of operation | movement in the document reading part in one embodiment of this invention. It is a flowchart (the 2) of the operation | movement in the document reading part in one embodiment of this invention. It is a flowchart (the 3) of operation | movement in the document reading part in one embodiment of this invention. It is a flowchart (the 4) of operation | movement in the document reading part in one embodiment of this invention. It is a figure which shows the intermediate language production | generation process in one embodiment of this invention. It is a flowchart of operation | movement of the design model production | generation part in one embodiment of this invention. It is a flowchart of operation | movement of the test item extraction part in one embodiment of this invention. It is a flowchart of operation | movement of the test item extraction part in one embodiment of this invention. It is a detailed flowchart of S340 in one embodiment of the present invention.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

  First, terms used in this specification will be described.

  “Screen transition diagram” refers to a document showing transitions between screens within a function. An example of a screen transition diagram is shown in FIG.

  The “screen element list” is a description in which definitions for input / output availability and attributes (text, pull-down list, etc.) are described for each component in the screen. An example of this is shown in FIG.

  The “input constraint definition document” describes restrictions on a single screen element to be input. An example of this is shown in FIG.

  The “processing event definition document” describes state transitions caused by events (mainly user operations) that occur on the screen. An example of this is shown in FIG.

  The “process overview flow definition document” is a process flow (main flow) for clarifying the behavior of the process. An example of this is shown in FIG.

  FIG. 8 shows the configuration of the test item generation device according to the embodiment of the present invention.

  The test item generation apparatus 100 shown in the figure includes a document reading unit 110, a design model generation unit 120, a test item extraction unit 130, a test item output unit 140, a screen transition diagram storage unit 101, an intermediate language storage unit 102, and a design model storage. Unit 103 and test item storage unit 104. Among these, the document storage unit 101, the intermediate language storage unit 102, the design model storage unit 103, and the test item storage unit 104 are storage media such as a hard disk device and a memory. Further, it is assumed that the document storage unit 101 stores the screen transition diagram, the screen element definition document, the process event definition document, the input constraint definition document, and the process outline flowchart shown in FIGS. The screen ID to which each of the screen element definition document, input constraint definition document, and process event definition document belongs is set.

  The operation in the above configuration will be described below.

  FIG. 9 is a flowchart of an outline operation in one embodiment of the present invention.

  Step 110) When the document reading unit 110 obtains a file path from the user terminal 200 connected to the test item generation device 100, the document reading unit 110 reads a design document group from the document storage unit 101 based on the file path. To the intermediate language (JavaObject) and stored in the intermediate language storage unit 102.

  Step 120) The design model generation unit 120 reads a document converted into JavaObject from the intermediate language storage unit 102, converts it into a single design model (XMI format UML), and stores it in the design model storage unit 103 as a conversion model. To do.

  Step 130) The test item extraction unit 130 reads the design model from the design model storage unit 103, and as test items, the presence / absence of an input error, the behavior of the process (test path), the presence / absence of DB change, the method of outputting the result, etc. These are extracted and stored in the test item storage unit 104 as test items.

  Step 140) The test item output unit 140 reads the test item from the test item storage unit 104, formats it into a form, and outputs it. FIG. 10 shows an output example.

  Details of the above steps will be described below.

  First, the detailed operation of the document reading unit 110 in step 110 will be described.

  FIG. 11 is a flowchart (No. 1) of the operation of the document reading unit in the embodiment of the invention.

  Step 210) Obtain a file path for reading the screen transition diagram input to the terminal 200, read the screen transition diagram corresponding to the specified file path from the document storage unit 101, and corresponding intermediate language (screen transition diagram object). Is generated, an intermediate language (screen object) corresponding to each screen of the screen transition diagram is generated, linked with the screen transition diagram object, and a list of screen objects is stored in the intermediate language storage unit 102.

  Step 220) Based on the screen ID included in the screen transition diagram generated in Step 210, the screen element definition document is read from the document storage unit 101, and the corresponding intermediate language (screen element object) is generated. The screen object list including the link information is generated, and the screen element object is stored in the intermediate language storage unit 102.

  Step 230) Based on the screen ID of the screen element definition document read in Step 220, the input constraint definition document is read from the document storage unit 101, and the corresponding intermediate language (input constraint object) is generated. An input constraint object including link information is stored in the intermediate language storage unit 102 by linking with the screen element object.

  Step 240) Based on the ID described in the screen element definition document, the process event definition document is read from the document storage unit 101, the corresponding intermediate language (process event object) is generated, and the screen element obtained in step 220 The process event object including the link information is stored in the intermediate language storage unit 102 by linking with the object.

  Step 250) Based on the screen ID of the processing event included in the processing event definition document read in Step 240, the processing outline flow diagram is read from the document storage unit 101, and the processing outline flow diagram (node and edge) is read. Intermediate language (processing outline flow object) to be generated is linked to the processing event object, and the screen element object including the link information is stored in the intermediate language storage unit 102.

  In the above process, instead of the process of step 210 in FIG. 11, the screen list may be converted into an intermediate language as shown in step 610 of FIG.

  Thereby, in addition to being able to input the screen transition diagram, the screen element definition document, the process event definition document, and the process overview flowchart in FIG. 11, the screen list can also be input as a design document.

  Further, the process of converting the screen element definition document in step 220 in FIG. 11 into an intermediate language may be omitted as shown in FIG.

  Further, the process of converting the input constraint definition document in step 230 of FIG. 11 into an intermediate language may be omitted as shown in FIG.

  FIG. 15 shows the relationship between the intermediate language (object) generated in steps 210 to 250 and the link.

  Next, detailed processing of step 120 in FIG. 9 will be described.

  FIG. 16 is a flowchart of the operation of the design model generation unit in one embodiment of the present invention.

  Step 310) The design model generation unit 120 reads the screen transition diagram object from the intermediate language storage unit 102 and stores it in the memory (not shown).

  Step 320) The screen element object linked to each screen object of each screen transition diagram object read in Step 310 is converted into the XMI format and additionally written to the design model storage unit 103. For example, “Stream http: // xstream. Codehaus.org/tutorial.html” is used as the conversion method to the XMI format.

  Step 330) The process event object linked to the screen object is converted into the XMI format and additionally written to the design model storage unit 103. The same method as described above is used for conversion to the XMI format.

  Step 340) The screen element object and the processing event object are read from the intermediate language storage unit 102, and the input restriction object processing outline flow object linked to the screen element object is merged to generate the entire flow object. Details of this processing will be described later with reference to FIG.

  Step 350) The entire flow object is converted into the XMI format using the above method, and additional writing is performed in the design model storage unit 103.

  The above steps 340 and 350 are repeated for all process event objects. Further, for all screen objects read in step 310 and stored in a memory (not shown), the steps after step 320 are performed. Repeat the process.

  Next, the processing of the test item extraction unit 130 in step 130 of FIG. 9 will be described.

  FIG. 17 is a flowchart of the operation of the test item extraction unit in one embodiment of the present invention.

  Step 410) The design model (XMI file) generated in Step 120 is read from the design model storage unit 103 and stored in a memory (not shown) as an overall flowchart.

  Step 420) The process event name of the process event to which each overall flow chart belongs is extracted.

  Step 430) Extract the execution path to be tested from the overall flow diagram.

  Step 440) The processing behavior (test path) is extracted from the execution path to be tested extracted in step 430, and stored in a memory (not shown).

  Step 450) The presence / absence of an input error is extracted from the execution path and stored in a memory (not shown). When an input error is detected, a flag indicating the input error is detected at the “end node” of the route.

  Step 460) The presence / absence of DB change is extracted from the execution path and stored in a memory (not shown).

  Step 470) The method of outputting the results is extracted from the execution path and stored in a memory (not shown).

  Step 480) Screen names obtained in Steps 440, 450, 460 and 470, stored in a memory (not shown), processing behavior (test path), presence of input error, presence / absence of DB change, result output The methods are grouped as one test item and stored in a memory (not shown).

  Step 490) A table (test item table) having grouped test item groups stored in a memory (not shown) as an element is created, and a processing event name corresponding to the entire flow diagram is assigned as a table name And stored in the test item storage unit 104.

  The above processing is performed on the entire flow diagrams in all the design models read in step 410.

  As shown in FIG. 18, the process of extracting the presence / absence of an input error in the above step 450 can be omitted.

  Next, a detailed operation of merging the process outline flow object and the input constraint object in step 340 of the design model generation unit 120 in FIG. 16 will be described.

  FIG. 19 is a detailed flowchart of S340 according to the embodiment of the present invention.

  Step 510) The process overview flow object is read from the intermediate language storage unit 102.

  Step 520) The input constraint object is read from the intermediate language storage unit 102.

  Step 530) For each input constraint item object in the input constraint item object list held by the input control object, an edge (true edge) corresponding to the case where the domain of the input constraint item object is satisfied is generated.

  Step 540) An edge (false edge) corresponding to the case where the domain of the input constraint item object is not satisfied is generated.

  Step 550) A branch node and an end node corresponding to the input constraint item object are generated, and if the input constraint item object is the input constraint item object at the head of the input constraint item object list, the process proceeds to step 570, and the head If there is no input restriction item object, the process proceeds to step 560. It is assumed that a flag indicating the presence or absence of an input error is set when generating the end node.

  Step 560) The end point of the true edge of the previous branch node in the input constraint item object list is connected to the branch node.

  Step 570) Connect the start point of the true edge to the branch node.

  Step 580) Connect the start point of the false edge to the branch node and the end point to the end node.

  The processes from step 530 to step 580 are repeated for each input constraint item object in the input constraint item object list held by the input constraint object.

  Step 590) Insert the input item tree immediately after the start node of the process overview flow object.

  As a result, it is possible to integrate individual intermediate format languages for each design document into one design model (XML format UML model).

  Further, the operations of the document reading unit 110, the design model generation unit 120, the test item extraction unit 130, and the test item output unit 140 of the test item generation device are constructed as programs and installed in a computer used as the test item generation device. Thus, it can be distributed or distributed through a network.

  Further, the constructed program can be stored in a portable storage medium such as a hard disk, a flexible disk, or a CD-ROM, and can be installed or distributed in a computer.

  The present invention is not limited to the above-described embodiment, and various modifications and applications can be made within the scope of the claims.

100 Test Item Generation Device 101 Document Storage Unit, Document Reading Unit 102 Intermediate Language Storage Unit, Intermediate Language Storage Unit 103 Design Model Storage Unit, Design Model Storage Unit 104 Test Item Storage Unit, Test Item Storage Unit 110 Document Reading Unit, Document Reading Unit 120 design model generation unit, design model generation unit 130 test item extraction unit, test item extraction unit 140 output unit, test item output unit 200 user terminal

Claims (9)

A test item generation device that generates a test item when performing an integration test using software design information,
Screen transition diagram showing transitions between screens in the function, screen element definition document describing definitions related to input / output and attributes for each component in the screen, input that is a restriction on the screen element alone Document memory that stores a constraint definition document, a process event definition document that describes state transitions caused by events that occurred on the screen, and a process overview flow definition document that describes the process flow for clarifying the behavior of the process Means,
Intermediate language storage means for storing objects converted from a document into an intermediate language;
Design model storage means for storing the generated design model;
Test item storage means for storing the extracted test items;
Document reading means for reading each document group from the document storage means and storing the object converted into a single intermediate language into the intermediate language storage means;
An object converted from the intermediate language storage means into the intermediate format language, integrated into a single design model, and stored in the design model storage means;
Test item extraction by acquiring the design model from the design model storage means, extracting the presence / absence of input error, test path, presence / absence of DB change, and method of outputting the results as test items, and storing them in the test item storage means Means,
An output means for reading out the test items from the test item storage means, forming them into a predetermined form format, and outputting them;
A test item generation device characterized by comprising: The document reading means includes:
Based on the designated file path, the screen transition diagram is read from the document storage means, a corresponding intermediate language screen transition diagram object is generated, and an intermediate language screen object corresponding to each screen of the screen transition diagram is generated. A list generated and linked with the screen transition diagram object is stored in the intermediate language storage means;
Based on the screen ID of the screen transition diagram, the screen element definition is read from the document storage means, a corresponding intermediate language screen element object is generated, and a list linked with the screen object is stored in the intermediate language storage means. Stored in
Based on the screen ID of the screen element definition document, the input constraint definition document is read from the document storage means, a corresponding intermediate language input constraint object is generated, and a list linked to the screen element object is displayed in the intermediate language. Stored in storage means,
Based on the screen ID of the screen element definition document, a processing event definition document is read from the document storage means, a corresponding processing event object in the intermediate language is generated, and a list linked to the screen element object is stored in the intermediate language storage. Stored in the means,
Based on the screen ID of the processing event definition document, a processing outline flow diagram is read from the document storage means, a processing outline flow object corresponding to the intermediate language is generated, and a list linked with the processing event object is displayed in the intermediate language. Means for storing in the storage means;
The design model generation means includes
A list in which the objects are linked is read from the intermediate language storage means,
The screen element object linked to the screen object is converted into a predetermined unified format using a unified format tool,
The processing event object linked to the screen object is converted into a predetermined unified format using the unified formatting tool,
The input constraint object linked to the screen element object and the process overview flow object linked to the process event object are merged to generate an overall flow object, and the overall flow object is converted to the unified format tool. The test item generation device according to claim 1, wherein the test item generation device converts the data into a predetermined unified format and stores it in the design model storage means. The document storage means includes
Instead of the screen transition diagram, store a screen list,
The document reading means includes:
A means for generating a screen object in an intermediate language corresponding to each screen of the screen list, and storing a list linked with the screen transition diagram object in the intermediate language storage means;
The test item generation device according to claim 2. The test item extraction means includes
The design model is read from the design model storage means, an execution path to be tested is extracted from the entire flow object converted into the predetermined unified format, and the test path and the presence / absence of an input error are detected from the execution path. Including means for extracting the presence / absence of a change and a result output method as test items, grouping them as one test item, generating a test item table, assigning a processing event name, and storing the result in the test item storage unit Item 4. The test item generation device according to any one of Items 1 to 3. A test item generation method for generating a test item when performing an integration test using software design information,
Screen transition diagram showing transitions between screens in the function, screen element definition document describing definitions related to input / output and attributes for each component in the screen, input that is a restriction on the screen element alone Document memory that stores a constraint definition document, a process event definition document that describes state transitions caused by events that occurred on the screen, and a process overview flow definition document that describes the process flow for clarifying the behavior of the process Means,
Intermediate language storage means for storing objects converted from a document into an intermediate language;
Design model storage means for storing the generated design model;
Test item storage means for storing the extracted test items;
In a device having
A document reading step of reading each document group from the document storage means and storing an object converted into a single intermediate language into the intermediate language storage means;
A design model generation step of integrating the object converted from the intermediate language storage means into the intermediate format language into a single design model and storing it in the design model storage means;
Obtaining the design model from the design model storage means, extracting the presence / absence of an input error, a test path, presence / absence of a DB change, and a method of outputting a result as test items,
An output step of reading out the test item from the test item storage means, forming it into a predetermined form format, and outputting it;
A test item generation method characterized by: In the document reading step,
Based on the designated file path, the screen transition diagram is read from the document storage means, a corresponding intermediate language screen transition diagram object is generated, and an intermediate language screen object corresponding to each screen of the screen transition diagram is generated. A list generated and linked with the screen transition diagram object is stored in the intermediate language storage means;
Based on the screen ID of the screen transition diagram, the screen element definition is read from the document storage means, a corresponding intermediate language screen element object is generated, and a list linked with the screen object is stored in the intermediate language storage means. Stored in
Based on the screen ID of the screen element definition document, the input constraint definition document is read from the document storage means, a corresponding intermediate language input constraint object is generated, and a list linked to the screen element object is displayed in the intermediate language. Stored in storage means,
Based on the screen ID of the screen element definition document, a processing event definition document is read from the document storage means, a corresponding processing event object in the intermediate language is generated, and a list linked to the screen element object is stored in the intermediate language storage. Stored in the means,
Based on the screen ID of the processing event definition document, a processing outline flow diagram is read from the document storage means, a processing outline flow object corresponding to the intermediate language is generated, and a list linked with the processing event object is displayed in the intermediate language. Performing the step of storing in the storage means;
In the design model generation step,
A list in which the objects are linked is read from the intermediate language storage means,
The screen element object linked to the screen object is converted into a predetermined unified format using a unified format tool,
The processing event object linked to the screen object is converted into a predetermined unified format using the unified formatting tool,
The input constraint object linked to the screen element object and the process overview flow object linked to the process event object are merged to generate an overall flow object, and the overall flow object is converted to the unified format tool. The test item generation method according to claim 5, wherein the step of converting to a predetermined unified format using the design model storage means is performed. The document storage means includes
Instead of the screen transition diagram, store a screen list,
The document reading step includes:
Generating an intermediate language screen object corresponding to each screen of the screen list, and storing the list linked with the screen transition diagram object in the intermediate language storage means;
The test item generation method according to claim 6. In the test item extraction step,
The design model is read from the design model storage means, an execution path to be tested is extracted from the entire flow object converted into the predetermined unified format, and the test path and the presence / absence of an input error are detected from the execution path. 6. The presence / absence of a change and a method of outputting a result are extracted as test items, grouped as one test item, a test item table is generated, a processing event name is given, and the test item storage unit stores the test event name. 8. The test item generation method according to any one of 7 above.   A test item generation program for causing a computer to function as each means constituting the test item generation device according to claim 1.

Images