JP5384587B2 - Test item generation apparatus, method and program for combination of abnormal scenarios - Google Patents

Description

  The present invention relates to a test item generation apparatus, method, and program for a combination of abnormal scenarios, and more particularly to a test abnormality system for extracting test items for testing a combination of abnormal scenarios based on a use case description. The present invention relates to a test item generation apparatus, method, and program for combination of scenarios.

  As a method for extracting test items for scenario tests based on conventional use case descriptions, UML activity diagrams (the same flow structure as use case descriptions) are used as input, and the permutation of routes that pass once through the loop There is a method of generating (see, for example, Non-Patent Document 1).

  In addition, there is a technique capable of extracting a test path (test item) that always passes through each edge of a screen transition diagram (the same flow structure as the use case description) at least once (see, for example, Patent Document 1).

JP-A-9-223040

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.

  The conventional Non-Patent Document 1 technique comprehensively extracts permutations of routes that pass through the loop route 0 times and 1 time from the use case description, and from there, test routes for all combinations of multiple types of abnormal scenarios It is also possible to select a method. However, if the number of abnormal scenarios increases, the number of permutations increases too much, and calculation with a realistic memory amount becomes impossible. For example, if there are 10 abnormal scenarios, there are 9,864,101 test paths extracted by the number of permutations.

  Further, the test items (test paths) extracted by the technique of Patent Document 1 do not cover all combinations. There may be a method of improving the technology and removing a specific abnormal scenario from the use case description and extracting the remaining abnormal scenarios from the use case description. It is not necessarily compatible with.

  The present invention has been made in view of the above points, and obtains a minimum test path for detecting an error caused by a combination that does not depend on the execution order of a plurality of types of abnormal scenarios with a realistic amount of memory. An object of the present invention is to provide a test item generation apparatus, method, and program for a combination of abnormal scenarios that can be used.

In order to solve the above problems, the present invention (Claim 1) provides an abnormal scenario for extracting test items of a combination of abnormal scenarios based on a use case description indicating a flow of interaction between a user and a system. A test item extraction device of a combination of
A design model input means for obtaining a use case description from the input design model;
Extracting all test paths that do not include loop paths from the use case description (hereinafter referred to as “loop without loops”), and adding the test path extraction means without loops to the test path set;
A test path including a loop path (hereinafter referred to as “path with loop”) is extracted from the use case description, and a new test path is generated by connecting the path without loop and the path with loop of the test path set. , A test path complementing means with a loop to be added to the newly added test path set,
Filtering means for adding a set excluding a normal scenario that is a basic flow of the use case description from the newly added test path set to the test path set, and storing the test path set in an execution path storage unit;
Execution path extraction means having
Test item generation means for reading the test path from the execution path storage means and generating test items for the test path.

Further, the present invention (Claim 2) provides the test path complementing means with a loop,
Means for adding, to the loop path edge queue, an edge that does not exist in the loop-less path among edges corresponding to the arrow portion of the use case description;
Means for taking out the leading edge X of the loop path edge queue and connecting the edge X to the loopless test path to generate the new test path until the loop path edge queue becomes empty; ,including.

Further, the present invention (Claim 3) is the test path complementing means with loop,
As a process for generating the new test path,
A test path in which a certain edge E exists in the path from the test path described in the use case description and a loop path edge is included in the next development edge group of the end point connection node of the edge E is extracted as a first-half test path set;
A test path starting from the loop path edge is extracted from the use case description as a second half test path set,
The first half test path set includes means for connecting a partial path from the loop path edge closest to the end edge to the end edge as the first half path and connecting to each second half test path in the second half test path set.

  According to the present invention, all test paths and loop paths that do not include loop paths are extracted from the use case description, and new test paths are extracted by connecting loop paths to test paths that do not include loop paths. Thus, it is possible to comprehensively obtain a minimum test path (test item) for detecting an error generated by a combination depending on the execution order of a plurality of types of abnormal scenarios.

  In addition, by creating new test paths for the number of combinations of patterns that connect n types of loop paths and combinations of patterns that are not connected to the path without loop in the use case description, one test path that does not include loops is created. It is possible to generate 2 n new test paths. In a typical use case description, about 10 abnormal scenarios are included. Compared with the number of all permutations extracted by the prior art, if the test paths (test items) are extracted in all combinations, the memory usage is about 1 / 10,000.

It is a block diagram of the test item generation apparatus of the scenario test in one embodiment of this invention. It is a block diagram of the execution path | route extraction part in one embodiment of this invention. It is a flowchart of the outline | summary operation | movement in one embodiment of this invention. It is a detailed flowchart of step 130 in one embodiment of the present invention. It is an example of the data structure of the input (use case description) in one embodiment of this invention. It is an image of the use case description in one embodiment of this invention. It is a detailed flowchart of step 230 in one embodiment of the present invention. It is a detailed flowchart of step 320 in one embodiment of the present invention. It is an example of the data structure of the output (test path | route set) in one embodiment of this invention. It is a detailed flowchart of step 440 in one embodiment of this invention. It is a detailed flowchart of step 330 in one embodiment of this invention. It is a detailed flowchart of step 660 in one embodiment of this invention. It is an example which extracts an abnormal test path | route from the use case description in one embodiment of this invention. It is an example which complements the test path with a loop in one embodiment of the present invention.

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

  First, terms used in this specification will be described first.

  ・ Scenario test: A test that confirms whether the system behaves according to the assumed scenario by creating a scenario based on the requirements defined by the user.

  Test items: Test items in the scenario test include a test scenario and a confirmation viewpoint. “Test scenario” is a sequence composed of screens and operations, and “confirmation viewpoint” includes correctness of screen transitions, correctness of screen display contents, presence / absence of database destruction, and the like.

  Screen transition diagram: A type of design document. Shows transitions between screens within a specific function.

  Use case description: A type of design document. It is also a notation to clarify requirements. The flow of interaction between the user and the system is shown. The flow proceeds along the “basic flow”, but may branch into an “alternate flow” and an “exception flow”.

  ・ Normal scenario: Refers to the basic flow in use case description. Consists of one or more edges.

  ・ Abnormal scenario: A generic term for alternative flows and exception flows in use case descriptions. It consists of one or more edges, branches from the normal scenario, and returns to the normal scenario.

  -Errors that occur depending on the combination without depending on the execution order of multiple types of abnormal scenarios: Each time an abnormal scenario is passed, a value is added to a specific variable, and as a result of the addition, the system assumes It is an error that performs a different action. For example, it indicates an error in which login is prohibited when the number of login failures is smaller than expected as a result of erroneously incrementing the number of login failures in a plurality of abnormal scenarios.

  Loop path: Consists of one or more edges. There are two cases:

1) Two or more edges E0, E1, ..., En
(Provided that E0 ≠ Ei (i = 1,..., N), and a partial path in which E0 is included in any of the next edges of En;
2) a partial path composed of one edge E0 and including E0 at the next edge of E0;
Edge: Arrow part of use case description. Nodes are connected to both sides (start point and end point) (however, only the start edge, no node is connected to the start point).

  Node: A section in a use case description. Holds the edge (connection to the start point) group.

  Start edge: An edge that exists in the use case description and represents the start of a route.

  End edge: One or more edges in the use case description that represent the end of the route.

  Edge stack: A stack for storing the edges traced in the use case description in order.

  Next development edge group: A candidate group of edges to be traced next (edges connected to the own node at the start point).

  Stack for next expanded edge group: A stack for storing the next expanded edge group that has not been traced in the path traced so far.

  Front edge group: An edge group connected to its own node at its end point.

  Current next developed edge group: the top of the next developed edge group stack.

  Current loop route: This is a route from the top edge of the stack to the current edge closest to the top of the previous routes (edges stacked on the edge stack).

  Loop appearance count: The number of times the loop has appeared in the route.

  FIG. 1 shows a configuration of a test item generating apparatus for scenario tests in an embodiment of the present invention.

  A test item generation apparatus 10 shown in FIG. 1 includes a design information reading unit 1, a design model analysis unit 2, an execution path extraction unit 3, an execution path storage unit 5, and a test item generation unit 6, and is connected to a user terminal 20. ing.

  The design information reading unit 1 reads the design model (XMI file) input from the user terminal 20 and passes it to the design model analysis unit 2.

  The design model analysis unit 2 extracts a use case description (UML Activity) screen transition diagram from the input design model, generates a design model (XML format), and passes it to the execution path extraction unit 3.

  The execution path extraction unit 3 generates a test path set from the use case description (UML Activity) of the design model, extracts an abnormal test path set from the test path set, and stores it in the execution path storage unit 5.

  As illustrated in FIG. 2, the execution path extraction unit 3 includes a design model input unit 31, a loopless path extraction unit 32, a looped test path complementation unit 33, and a filtering unit 34.

  The execution path storage unit 5 stores the test path extracted by the execution path extraction unit 3.

  The test item generation unit 6 acquires an execution path from the execution path storage unit 5, generates a test item table (Excel format), and outputs it to the user terminal 20.

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

  Step 110) The design information reading unit 1 reads a design document group from the user terminal 20.

  Step 120) The design model analysis unit 2 generates a design model (XML format) from the read design document group. Here, “XStream http://xstream.codehaus.org/tutorial.html” is used as a method for generating a design model (XML format). The generated design model is output to the execution path extraction unit 3.

  Step 130) The execution path extraction unit 3 extracts test items and stores them in the execution path storage unit 5. Detailed processing will be described in detail with reference to FIG.

  Step 140) The test item generation unit 6 reads the execution path from the execution path storage unit 5, generates a test item table, and outputs it to the user terminal 20.

  Next, the processing in step 130 of the execution path extraction unit 3 will be described in detail.

  FIG. 4 is a detailed flowchart of step 130 in one embodiment of the present invention.

  Step 210) The design model input unit 31 of the execution path extraction unit 3 reads the design model (XML file) generated by the design model analysis unit 2, extracts use case descriptions in the design model, and uses case description list Is generated and stored in a memory (not shown). As shown in FIG. 5, the use case description includes a node ID, intra-node text, previous edge group, next expanded edge group, edge ID, start point connection node ID, end point connection node ID, transition condition, and type. Yes. A structural image of the use case description of FIG. 5 is shown in FIG.

  Step 220) The loopless route extraction unit 32 of the execution route extraction unit 3 reads the use case description list.

  Step 230) The loopless path extraction unit 32 and the looped test path complementation unit 33 of the execution path extraction unit 3 extract an abnormal test path from the use case description list. Detailed processing will be described in detail with reference to FIG.

  Step 240) The filtering unit 34 of the execution path extracting unit 3 performs filtering, and performs a process for collecting the abnormal system paths of the test items after filtering as test items on all the abnormal test paths.

  Step 250) The filtering unit 34 creates a test item table having the test item group as an element and stores it in the execution path storage unit 5.

  Next, processing for extracting an abnormal test path from the use case description list by the execution path extracting unit 3 in step 230 will be described.

  FIG. 7 is a detailed flowchart of step 230 in one embodiment of the present invention.

  Step 310) The loopless route extraction unit 32 of the execution route extraction unit 3 reads the use case description.

  Step 320) The loopless path extraction unit 32 extracts a loopless path from the use case description and adds it to a test path set on a memory (not shown). Detailed processing will be described in detail with reference to FIG. The loopless path obtained in this step is a minimum set of test paths that cover all combinations of “abnormal system scenarios not included in the loop path”.

  Step 330) The test path complementing unit with loop 33 extracts the test path with loop from the use case description and adds it to the test path set on the memory (not shown). Detailed processing will be described in detail with reference to FIG.

  Step 340) The filtering unit 34 reads a test path set from a memory (not shown), and extracts only an abnormal test path (alternate flow / exception flow) from the test path set.

  The process of extracting the loop-free route in step 320 will be described.

  FIG. 8 is a detailed flowchart of step 320 in one embodiment of the present invention.

  Step 410) The loopless path extracting unit 32 loads the initial next expanded edge group (added only the initial edge) from the use case description into the next expanded edge group stack of the memory (not shown).

  Step 415) If the next developed edge group stack is empty, the process is terminated. If not, the process proceeds to Step 416.

  Step 416) If there is an element in the next development edge group at the top of the stack for the next development edge group, the process proceeds to step 420. If there is no element, the process proceeds to step 480.

  Step 420) One edge is obtained from the element (current (next development edge group)) at the top of the next development edge group stack of the memory (not shown) and is set as the current edge.

  Step 430) Remove the current edge group from the current edge group.

  Step 440) Calculate the number of occurrences of the loop in the path (a sequence of edges stacked on the edge stack). Details will be described in detail with reference to FIG.

  Step 445) If the number of occurrences of the loop obtained in Step 440 is greater than 0, the process returns to Step 415, and if it is 0 or less, the process proceeds to Step 450.

  Step 450) Stack the current edge onto the edge stack.

  Step 460) Based on the end point connection node ID of the current edge, the node is acquired from the use case description, the edge (connection with the start point) group of the node is acquired, and the acquired edge (connection with the start point) The group is loaded on the next expansion edge group stack as the next expansion edge.

  Step 470) The path (sequence of edges stacked on the edge stack) is added as a test path to the test path set, and the process returns to Step 415. An example of the test path set is shown in FIG.

  Step 480) If there is no element in the next development edge group at the top of the next development edge group stack in Step 416, the next development edge group stack is hopped.

  Step 490) If the edge stack is not empty, the edge stack is hopped and the process is terminated.

  Next, a process of calculating the number of appearances of the current loop path in the path of the above-described step 440 (sequence of edges stacked on the edge stack) in the loopless path extraction unit 32 will be described.

  FIG. 10 is a detailed flowchart of step 440 in one embodiment of the present invention.

  Step 510) The loopless path extraction unit 32 reads the current edge selected in Step 420.

  Step 520) Read a path (a sequence of edges stacked on the edge stack).

  Step 530) The route is duplicated, and the duplicated route is set as a search-in-progress route.

  Step 540) The current loop route is extracted from the beginning of the route being searched to the nearest current edge.

  Step 550) How many times the current loop path appears in the search path (the number of loop occurrences) is described in Reference 1 “RS Boyer; JS Moore (1977).“ A fast string searching algorithm ”. Comm. ACM 20: 762 -772 "etc.

  Next, the process of complementing the looped test path in step 330 of FIG. 5 in the looped test path complementing unit 33 will be described. In contrast to the minimum set of test paths that cover all combinations of “abnormal system scenarios not included in the loop path” of the in-loop test paths extracted in step 320, the processing is “included in the loop path”. Since all the “abnormal system scenarios” are connected to each other, a combination of “all abnormal system scenarios” is generated as a result.

  FIG. 11 is a detailed flowchart of step 330 in one embodiment of the present invention.

  Step 610) The test path complement unit 33 with loop reads the use case description.

  Step 620) The test path set is read from the memory (not shown) generated in Step 320.

  Step 630) A loop path edge queue for storing edges is prepared on a memory (not shown).

  Step 640) Among the edges constituting the use case description, the edges that do not exist in the test path in the test path set read in Step 320, in other words, all the edges that exist in the loop path are added to the loop path edge queue. .

  Step 650) Extract one edge (loop path edge) from the loop path edge queue.

  Step 660) When the loop path edge is included in the loop path edge queue, the loop path including the loop path edge is connected to the test path included in the test path set, and a plurality of new test paths are created, and this is newly added test. Let it be a route set. Detailed processing will be described in detail with reference to FIG.

  Step 670) Remove all edges included in the test path of the newly added test path set from the loop path edge queue.

  Step 680) Add the newly added test path set to the test path set.

  Step 690) In step 650, if the loop path edge queue does not include the loop path edge, the loop path edge is re-entered in the loop path edge queue.

  The processing shown in FIG. 11 above, for example, when [A, B, C] is in the loop path edge queue and a certain abnormal scenario is composed of three edges A⇒B⇒C, is extracted first. If the loop path edge is “A”, a test path “... ⇒ A ⇒ B ⇒ C ⇒...” Including an abnormal scenario is extracted in step 660. At this stage, since the abnormal system scenario A⇒B⇒C has already been extracted, it is not necessary to perform the processing of step 660 for [B, C] remaining in the loop path edge queue. Such edges (B, C) are excluded.

  Next, a process of creating a new test path by connecting the loop path including the loop path edge in step 660 to the test path in the test path complementing unit 33 with loop will be described.

  FIG. 12 is a detailed flowchart of step 660 in one embodiment of the present invention.

  Step 710) The test path complementing unit with loop 33 reads the use case description given in Step 660.

  Step 720) Similarly, the test path set given in Step 660 is read.

  Step 730) Read the loop path edge from the loop path edge queue.

  Step 740) From the test path set, an edge E exists in the path, and a test path in which the loop path edge is included in the next developed edge group of the node corresponding to the end point connection node ID of the edge E is determined as the test path for the first half path. Select all as a set.

  Step 750) Extract the second half path set related to the loop path edge from the test path set. The latter half route set is a set of test routes (second half route) starting from the loop route edge based on the use case description.

  Step 760) A newly added test path set (initially empty) is prepared on the memory.

  Step 770) The partial path from the loop path edge closest to the end edge to the end edge is taken out as the first half path.

  Step 780) The first half path and the second half path are connected by a loop path edge to create a new path (newly added test path).

  Step 790) Add the newly added test path to the newly added test path set.

  The above test route complementing unit with loop 33 can generate a new test route (new added test route) by connecting the loop route to the test route not including the extracted loop route. It is possible to create new additional test paths corresponding to the number of combinations of patterns that connect n types of loop paths (L1, L2,..., Ln) and combinations of unconnected patterns. That is, 2 n new test paths can be generated for one test path that does not include a loop.

  The abnormal system test path extraction process in step 230 will be specifically described.

  FIG. 13 shows an example in which an abnormal test path is extracted from the use case description according to the embodiment of the present invention. In the figure, a thick arrow indicates a normal edge, and a broken arrow indicates an abnormal edge.

From the use case description, normal scenario ABCD
As an abnormal scenario,
(1) X
(2) YZ
(3) W
There is. In the loopless route extraction unit 32, as a loopless route,
・ ABCD
・ ABCW
Are extracted as a test path set (step 320).

  As a result, all test paths that do not include a loop path are a minimum set of test paths that cover all combinations of “abnormal system scenarios that are not included in the loop path”, and all combinations of multiple types of abnormal system scenarios. The minimum set of test paths that cover

  Next, the looped test route complementing unit 33 supplements the following looped route (step 330).

-ABCD (no loop)
・ ABCW (no loop)
・ ABAXBCD (with loop)
・ ABYZBCD (with loop)
・ ABXBYZBCD (with loop)
・ ABXBCW (with loop)
・ ABAYZBCW (with loop)
・ ABXBYZBCW (with loop)
Of the above paths, ABCD is a normal scenario and is removed by filtering 34 (step 340). As a result, as an abnormal test path set,
・ A⇒B⇒C⇒W (no loop)
・ A⇒B⇒A⇒X⇒B⇒C⇒D (with loop)
・ A⇒B⇒Y⇒Z⇒B⇒C⇒D (with loop)
・ A⇒B⇒X⇒B⇒Y⇒Z⇒B⇒C⇒D (with loop)
・ A⇒B⇒X⇒B⇒C⇒W (with loop)
・ A⇒B⇒A⇒Y⇒Z⇒B⇒C⇒W (with loop)
・ A⇒B⇒X⇒B⇒Y⇒Z⇒B⇒C⇒W (with loop)
Remains. Since these are all combinations of the above three abnormal system scenarios (1) to (3), the following seven patterns are obtained.

・ (1)
(2)
・ (3)
・ (1) (2)
・ (2) (3)
・ (1) (3)
・ (1) (2) (3)
The above seven patterns form an abnormal test set and are stored in the execution path storage unit 5.

  Next, an example of complementing the looped test path in step 330 of FIG.

  FIG. 14 shows an example of complementing a test path with a loop according to an embodiment of the present invention.

  In the use case description, it is assumed that the following two routes are extracted as loopless test routes.

・ A⇒B⇒C⇒D
・ A⇒B⇒C⇒W
The test path complementing unit with loop 33 prepares a loop path edge queue on the memory and adds all the edges that do not exist in the test path without a loop. In the example of FIG. 14, the loop path edge queue includes
[X, Y, Z, W]
Is added (steps 630 and 640).

Next, the head X of the loop picture path edge queue is extracted (step 650). The loop path edge X is connected between the paths ABCD and ABCW to generate a new path (step 660). In the example of FIG. 14, by connecting the loop path edge X between the first half path A⇒B, the second half path B⇒C⇒D, and the second half path B⇒C⇒W, the newly added test path A⇒B⇒X⇒ B⇒C⇒D
A⇒B⇒X⇒B⇒C⇒W
Are generated and added to the test path set,
・ A⇒B⇒C⇒D
・ A⇒B⇒C⇒W
・ A⇒B⇒X⇒B⇒C⇒D
・ A⇒B⇒X⇒B⇒C⇒W
It becomes. The above processing is performed for each of the loop path edge queues [Y, Z, W] (step 680).

Each test path extracted by the above-described loop-less test path extraction unit 32 is a minimum set of test paths covering a combination of “abnormal system scenarios not included in the loop path”. In 33, since all abnormal scenarios included in the loop route are connected to each other, the resulting test route is the minimum set of test routes that cover the combinations of “all abnormal scenarios”. That is, the number of combinations A obtained by the test path extraction unit 32 without loop and the number B of combinations obtained by the test path complementing unit 33 with loop
A × B = total number of combinations. This is because only test paths of all combinations of abnormal scenarios are extracted, so that it is possible to obtain test items with a memory usage that is overwhelmingly smaller than in the conventional technique that extracts all permutations.

  The operation of each component of the test item generation device 10 shown in FIG. 1 can be constructed as a program, installed on a computer used as the test item generation device, executed, or distributed via a network. It is.

  The present invention is not limited to the above-described embodiments, and various modifications and applications are possible within the scope of the claims.

DESCRIPTION OF SYMBOLS 1 Design information reading part 2 Design model analysis part 3 Execution path extraction part 5 Execution path storage part 6 Test item generation part 10 Test item generation apparatus 20 User terminal

Claims (7)

A test item extraction device for an abnormal scenario combination that extracts test items for an abnormal scenario combination based on a use case description indicating a flow of interaction between a user and a system,
A design model input means for obtaining a use case description from the input design model;
Extracting all test paths that do not include loop paths from the use case description (hereinafter referred to as “loop without loops”), and adding the test path extraction means without loops to the test path set;
A test path including a loop path (hereinafter referred to as “path with loop”) is extracted from the use case description, and a new test path is generated by connecting the path without loop and the path with loop of the test path set. , A test path complementing means with a loop to be added to the newly added test path set,
Filtering means for adding a set excluding a normal scenario that is a basic flow of the use case description from the newly added test path set to the test path set, and storing the test path set in an execution path storage unit;
Execution path extraction means having
A test item generation unit that reads the test path from the execution path storage unit and generates a test item for the test path;
A test item generation device for a combination of abnormal scenarios characterized by comprising: The looped test path complement means is:
Means for adding, to the loop path edge queue, an edge that does not exist in the loop-less path among edges corresponding to the arrow portion of the use case description;
Means for taking out the leading edge X of the loop path edge queue and connecting the edge X to the loopless test path to generate the new test path until the loop path edge queue becomes empty; ,
The test item generation device for a combination of abnormal scenarios according to claim 1. The looped test path complement means is:
As a process for generating the new test path,
A test path in which a certain edge E exists in the path from the test path described in the use case description and a loop path edge is included in the next development edge group of the end point connection node of the edge E is extracted as a first-half test path set;
A test path starting from the loop path edge is extracted from the use case description as a second half test path set,
3. The abnormality according to claim 2, further comprising means for setting a partial path from a loop path edge closest to an end edge to an end edge in the first half test path set as a first half path and connecting the second half test path in the second half test path set. A test item generation device for a combination of system scenarios. A test item generation method for an abnormal scenario combination that extracts test items for an abnormal scenario combination based on a use case description indicating a flow of interaction between a user and a system,
A design model input step in which the design model input means obtains a use case description from the input design model;
A test path extraction means without a loop extracts all test paths that do not include a loop path from the use case description (hereinafter referred to as `` path without loop ''), and adds a test path without loop to add to the test path set;
A test route complementing means with a loop extracts a test route including a loop route from the use case description (hereinafter referred to as a “route with a loop”), and connects the route without the loop and the route with the loop of the test route set. A test path complementing step with a loop that generates a new test path and adds it to the newly added test path set,
A filtering step in which filtering means adds a set obtained by excluding a normal scenario that is a basic flow of the use case description from the newly added test path set to the test path set, and stores the test path set in the execution path storage means When,
An execution path extraction process including
A test item generating step for reading the test path from the execution path storage unit and generating a test item for the test path;
A test item generation method for a combination of abnormal scenarios characterized by: In the looped test path completion step,
Of the edges corresponding to the arrow part of the use case description, an edge that does not exist in the loop-less path is added to the loop path edge queue,
Taking the leading edge X of the loop path edge queue and connecting the edge X to the loopless test path to generate the new test path is repeated until the loop path edge queue is empty,
5. A test item generation method for a combination of abnormal scenarios according to claim 4. In the looped test path completion step,
As a process for generating the new test path,
A test path in which a certain edge E exists in the path from the test path described in the use case description and a loop path edge is included in the next development edge group of the end point connection node of the edge E is extracted as a first-half test path set;
A test path starting from the loop path edge is extracted from the use case description as a second half test path set,
6. The abnormal scenario according to claim 5, wherein a partial path from a loop path edge closest to an end edge to an end edge in the first half test path set is defined as a first half path and connected to each second half test path in the second half test path set. Test item generation method for combination. Computer
A test item generation program for causing each of the means of the test item generation apparatus according to any one of claims 1 to 3 to function.

Images