JP5523526B2 - Test data generation apparatus, method and program having multiple reference accesses in test path - Google Patents

Description

  The present invention relates to a test data generation apparatus, method, and program having a plurality of reference accesses in a test path, and more particularly to a functionality test that involves a read operation of data stored in a DB (database). In particular, the present invention relates to a test data generation apparatus, method, and program for generating test data including a plurality of reference accesses (SELECT) in a test path.

  There are the following test data generation techniques for functional tests that involve an operation of reading data stored in a database. Here, the test data is a pair of the initial state of the database (hereinafter referred to as “DB initial state”) and the input value. To test the database application, to the input field of each screen at the time of test execution Is used as a data set to be entered in advance in the database.

  Conventionally, a method for generating a test case (including an initial DB state) (for example, refer to Non-Patent Document 1) using a precondition described for each test case as an input, and a software design information as an input, There is a method of extracting a precondition of the test case and generating a DB initial state that satisfies the precondition of the test case for each test case (for example, see Non-Patent Document 2).

Shoichiro Fujiwara, Kazuki Munakata, Asako Katayama, Yoshiharu Maeda, Kenji Oki, Tadahiro Uehara, Rieko Yamamoto, generation of web application test using smt solver, 50th anniversary commemoration of IPSJ (72nd) National Conference Proceedings, 2010. Omon Tanno, Akira Zhang, Takashi Hoshino: "Automatic generation of test database using design model", Transactions of Information Processing Society of Japan: Special Issue on Software Engineering, Vol. 53, No.2, pp. 566-577, 2012 .

  However, if the search condition space for the same column overlaps, using the above conventional method, records that differ from the number of records planned under the guard condition on the test path (integer constraints such as integer arithmetic expressions and integer comparison operators) There is a problem that the number of cases is returned.

  Moreover, since these technologies generate one DB initial state per test case, they can handle only SELECT access of DB definition (Persons) at most once. Therefore, there is a problem that the number of times of initial DB replacement is large every time the test is performed. For example, there are the input value definition and DB definition (Persons) shown in Fig. 1. In the test case extracted from the process flow diagram, "SELECT * FROM Persons WHERE Age <= maxAge AND Age> = minAge" is given as the SELECT statement. If this is done (when one SELECT statement is used), test data with two search result records can be obtained as shown on the right side of the figure. However, if there are multiple reference accesses and conditional branches for the same table (Persons), there is a problem that it cannot be handled.

  The present invention has been made in view of the above points, and can generate a test case for executing a subsequent SELECT statement in accordance with the number of search result records of a plurality of SELECT statements, and the initial DB of the test execution It is an object of the present invention to provide a test data generation apparatus, method, and program having a plurality of reference accesses in a test path capable of reducing the number of state replacements.

In order to solve the above-described problem, the present invention (Claim 1) provides a plurality of reference accesses in a test path for generating test data having a plurality of reference accesses to a database (DB) during the test path. A data generator for testing with
A test case extraction means for extracting a test case from the inputted design information and storing it in the test case storage means;
The test cases are read from the test case storage means, and test cases that can share the same initial DB state are grouped as test case groups so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. , Test case grouping means for storing in the test case group set storage means,
The test case group is read from the test case group set storage means, a constraint expression of the input variables of the test cases of the test case group is generated, and stored in the constraint set of the test case group set storage means including the test case. Input variable constraint expression generation means;
Obtaining the test case group from the test case group set storage means, obtaining a DB table variable of a test case included in the test case group from the test case storage means , determining a record number of the DB table variable; The process of adding a SELECT query to the reference query group of the DB table variable is repeated for the number of records , added to the reference query group of the DB table variable of the record arrangement table storage unit, and the DB of the record arrangement table storage unit Record placement determining means for reflecting table variables in the test case group set storage means ;
For the DB table variables included in the test case a group of the test case group set storage unit, generates a constraint equation to ensure uniqueness, and DB table variable constraint expression generating means for storing in the test case groups set storage unit ,
Constraint equation solving means that solves the constraint expression stored in the test case group set storage means using an arbitrary solution and outputs the input value for each test case and the DB initial state sharing the test case as test data And having.

The present invention (Claim 2) is the test case grouping means,
Means for arbitrarily selecting one test case from the test cases to be grouped and substituting the DB table variable of the selected test case into the DB table variable of the test case group;

In the present invention (Claim 3), in the record arrangement determining means,
Means for setting the number of records to be the total number of search result records for each reference query.

Further, the present invention (Claim 4), in the DB table variable constraint expression generation means,
It includes means for generating a record that meets a condition of a WHERE clause referenced by a SELECT statement of the DB table variable of the record arrangement table storage unit , and generating a record so that a record that is not referenced does not match the condition of the WHERE clause.

  As described above, according to the present invention, for each SELECT statement, a record that the SELECT statement references generates a record that meets the conditions of the WHERE clause, and a record that does not reference generates a record that does not match the conditions of the WHERE clause. Therefore, with each reference access on the test path, it is guaranteed that the expected number of records will be returned without excess or deficiency, and as a result, the subsequent SELECT statement will be returned according to the number of records in the reference result of the previous SELECT statement. It is possible to generate an initial DB state that constitutes test data for testing a test case (test path) to be executed.

  In the present invention, by grouping test cases that reuse the same DB initial state, one DB initial state is generated so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. Therefore, the DB initial state generated as a result becomes the DB initial state constituting the test data for each test case (each test pass). In addition, the number of DB initial state replacements can be reduced.

It is an example of test case generation in the prior art. It is a figure which shows the outline | summary of the test data generation in one embodiment of this invention. It is a block diagram of the test data generation device in one embodiment of the present invention. It is an example of the DB definition input in one embodiment of this invention. It is an example of the test case (path | route) input in one embodiment of this invention. It is an example of the input value definition input in one embodiment of this invention. It is a flowchart of outline | summary operation | movement of the test data generation apparatus in one embodiment of this invention. It is a data structure stored in the test case group set storage part in one embodiment of this invention. It is a flowchart of the detailed process of the test case extraction part in one embodiment of this invention. It is a storage example of the test case memory | storage part in one embodiment of this invention. It is a flowchart of the detailed process of the test case grouping part in one embodiment of this invention. It is an example of the test data grouping in one embodiment of the present invention. It is a flowchart of the detailed process of the input variable constraint expression production | generation part in one embodiment of this invention. It is a flowchart of the detailed process of the record arrangement | positioning determination part in one embodiment of this invention. It is an example of operation | movement of the record arrangement | positioning determination part in one embodiment of this invention. It is a flowchart of detailed processing of the DB table variable constraint generator according to an embodiment of the present invention. An operation example of the DB table variable constraint generator according to an embodiment of the present invention. It is an output example from the test data output part in one embodiment of this invention.

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

  In the present invention, as shown in FIG. 2, an input value definition, a test case (path), and a DB definition (in the present embodiment, a Persons table) are input as design information (XML). In the test case, the same table (Persons) is accessed n times (2 times in the example in the figure) and the conditional branching of C1 and C2 is performed twice. As shown on the right side of the figure, test data for controlling two branches (C1, C2) is generated from the design information. In the example shown in the figure, 0 records are returned for the conditional branch C1, and 2 records are returned for C2.

  FIG. 3 shows a configuration of the test data generation apparatus according to the embodiment of the present invention.

Test data generating apparatus 1 shown in FIG. 1, test case extraction unit 10, the test case grouping unit 30, the input variable constraint expression generation unit 40, the record allocation determination unit 50, DB table variable constraint generator 60, constraint solving Unit 70, test data output unit 80, test case storage unit 15, test case group set storage unit 35, and record arrangement table memory 55. The test case storage unit 15, the test case group set storage unit 35, and the record arrangement table memory 55 are storage media such as a hard disk and a memory. In addition, the record arrangement table memory 55 is provided outside the record arrangement determining unit 50, but is not limited to this example, and may be provided in the record arrangement determining unit 50.

  First, data input from the terminal 2 to the test data generation device 1 will be described.

  4 to 6 show examples of design information of the present invention.

  FIG. 4 is an example of a DB definition input according to the embodiment of the present invention.

  DB definition (Persons table) is DB table ID, DB record column, column ID (String type and domain, column type (Normal / Primary Key)), type and domain, integer domain, column type, etc. Is defined.

  FIG. 5 is an example of a test case (path) that is input in one embodiment of the present invention. The processing flow diagram shown in Fig. 2A consists of a node indicating the processing content and an edge indicating the transition from one processing to the next, and the node, node content, and query (SELECT, UPDATE, INSERT, DELETE) ID , Column and setting value, WHERE clause condition group, next node connection edge group, edge, guard condition, integer constraint, integer arithmetic expression, integer term, integer comparison operator, integer factor, column reference, variable reference, etc. Yes. Note that the SELECT query includes ResultRecordCount.

  FIG. 6 is an example of an input value definition to be input in an embodiment of the present invention.

  An input value definition includes an input value, a String type and a domain of the input value.

  Processing in the above configuration will be described.

  FIG. 7 is a flowchart of an outline operation of the test data generation apparatus according to the embodiment of the present invention.

  Step 110) The test case extraction unit 10 extracts a test case from the design information (XML format) input from the terminal 2, and stores it in the test case storage unit 15. Detailed operation will be described in detail with reference to FIG.

  Step 130) The test case grouping unit 30 reads the test cases extracted in step 110 from the test case storage unit 15, groups the test cases that reuse the same DB initial state as test case groups, and sets the test case group storage unit. 35. As shown in FIG. 8, the test case group set storage unit 35 stores test cases acquired from the test case storage unit 15 for each test case group ID (test case + constraint set, DB table variable). The test case includes test case Id, FlowId, (test path, converted update query), constraint set, DB table variable, DB field variable, reference group query (SELECT query), input variable, and integer type variable.

  In the present embodiment, it is assumed that grouping is performed based on a parameter input for grouping a reference query input by the user. Detailed operation will be described in detail with reference to FIG.

  Step 140) The input variable constraint expression generation unit 40 acquires a test case group from the test case group set storage unit 35, acquires test cases included in the test case group from the test case storage unit 15, and inputs the test cases. A variable constraint equation is generated and added to the constraint set for each test case group in the test case group set storage unit 35. This process is repeated for all the test cases that have been acquired. Detailed processing will be described in detail with reference to FIG.

  Step 150) The record arrangement determining unit 50 reads the test case group from the test case group set storage unit 35, and acquires the DB table variable of the design information of the test case group from the test case storage unit 15. Based on the DB table variable, the number of records in the DB table to be finally generated and the position where the record that hits each reference query is arranged are determined. The number of records is the total number of search result records (ResultRecordCount) of queries (SELECT) of each DB table, and the process of adding a SELECT query to the DB table variable reference query group is repeated for the number of records, and the test case group This is added to the reference query group of the DB record variable in the set storage unit 35. Detailed processing will be described in detail with reference to FIG.

  Step 160) The DB table variable constraint expression generation unit 60 reads the test case group from the test case group set storage unit 35, extracts the DB table variable of the test case included in the test case group, and the constraint on each DB field variable An expression is generated and added to the constraint set of the test case group in the test case group set storage unit 34. In addition, a constraint expression related to the input variable of each test case is also generated and added to the constraint set in the same manner. Detailed processing will be described in detail with reference to FIG.

  Step 170) The constraint equation solving unit 70 reads the constraint set of the test case group in the test case group set storage unit 35, extracts the constraint equation, solves the simultaneous inequality, obtains one solution at random, and obtains the test case group. Store in the collective storage unit 35. To solve the simultaneous inequality, an existing constraint solver (Trends in constraint Programming (Frederic Benhamou et. Al., Wiley-ISTE, 1905209975, 2007)) is used.

  Step 180) The test data output unit 80 uses the input value for each test case acquired from the test case group set storage unit 35 and one DB initial state value to be used in the test case as test data used by this test case group. And output as For this processing, for example, the technique described in Patent Document 1: Japanese Patent Application Laid-Open No. 2010-267022 can be applied.

  The operation of each step in FIG. 7 will be described in detail below.

<Process of Test Case Extraction Unit (Step 110)>
Next, the process of the test case extraction unit 10 in step 110 of FIG. 7 will be described.

  FIG. 9 is a flowchart of detailed processing in S110 according to the embodiment of the present invention.

  Step 210) The test case extraction unit 10 extracts a test path from the processing flow diagram of the input design information. For example, in the example of FIG. 5, all test paths are extracted so as to satisfy the branch condition C1 coverage.

  Step 220) Next, a test case having the test path is created from the extracted test path and stored in the test case storage unit 15. As a test case creation method, Patent Document 1 (Patent No. 4966386) for extracting a test case corresponding to each path extracted from the processing flow diagram (one extracted path becomes one test case) Can be used.

  Step 230) Obtain the DB definition of the design information, extract the DB table variable, and add it in association with the test case in the test case storage unit 15. An example of adding a DB table variable to the test case storage unit 15 is shown in FIG.

  Step 240) The input value definition of the design information is read, input variables and constraints are extracted, added to the test case in the test case storage unit 15 as shown in FIG. In the example of FIG. 6, the type, minimum value, and maximum value corresponding to the name of the green space are extracted and added as input variables in FIG. 10 in association with the test case.

<Processing of test case grouping unit (step 130)>
Next, the process of the test case grouping unit 30 in step 130 in FIG. 7 will be described. In this process, the test cases that use the DB initial state are grouped and stored in the test case group set storage unit 35.

  FIG. 11 is a flowchart of detailed processing of the test case grouping unit according to the embodiment of the present invention.

  Step 610) The test case grouping unit 30 reads a test case set from the test case storage unit 15.

  Step 620) An empty test case group set is generated on the test case group set storage unit 35.

  Step 630) An empty reference query test case set is generated in the test case group set storage unit 35.

  Step 650) The test case read in Step 610 is added to the reference query test case set in the test case group set storage unit 35. This process is performed for all test cases in the test case set.

  Step 657) A grouping parameter for collecting reference query test cases is acquired from the user.

  Step 660) Group test cases based on the grouping parameters. In the present invention, the grouping parameter is for the reference query test case, and is not applied to other update queries.

  Specifically, if the input grouping parameter is {[1, 2, 3], [4, 5]}, the test case group of the reference query with ID 1, 2, 3 and ID 4, 5 Each test query group of reference queries is grouped as one test group. At this time, records are extracted so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. In addition, you may apply arbitrary techniques, without being limited to using the input grouping parameter.

  Step 680) An arbitrary test case belonging to the test group is selected. The DB table variable group is the same regardless of which test case is selected.

  Step 690) The DB table variable of the selected test case is duplicated, substituted into the DB table variable of the test case group, and added to the test case in the test case group set storage unit 35 as shown in FIG. In the figure, the test cases are grouped based on designation of user input parameters.

  In the present invention, as described above, by creating a DB initial state that can be used by grouped test cases by grouping a plurality of test cases, one DB initial state is generated for one test case. The number of replacements of the DB initial state is less than that of the prior art.

<Processing of Input Variable Constraint Expression Generation Unit (Step 140)>
Next, the processing of the input variable constraint expression generation unit 40 in step 140 of FIG. 7 will be described.

  FIG. 13 is a flowchart of detailed processing of the input variable constraint expression generation unit in one embodiment of the present invention. Conventional techniques can be used to generate the input variable constraint equations shown below.

  Step 810) The input variable constraint expression generation unit 40 reads the test case group from the test case group set storage unit 35.

  Step 820) Extract test cases from the set of read test cases.

  Step 830) For all the input variables of the extracted test cases, a constraint expression is generated from the domain of the input variables. Specifically, let X be the input variable. Get the minimum value (Min Value) and maximum value (Max Value) of the “integer domain” of the input value definition corresponding to the input variable X, and generate a new constraint expression of X ≧ Min Value, X ≦ Max Value The process of adding to the constraint set in the test case group set storage unit 35 in association with the test group is repeated for each input variable of the input variable.

  Step 840) The guard condition included in the processing flow diagram (see FIG. 5) and the test case group acquired from the test group set storage unit 35 are input, and the integer constraint of the guard condition is set as the test of the test case group set storage unit 35. Add to the case group constraint set.

<Processing of Record Placement Determination Unit (Step 150)>
Next, the process of the record arrangement determining unit 50 in step 150 of FIG. 7 will be described.

  This process is to create a record arrangement table by associating a DB table with a query in the record arrangement table.

  FIG. 14 is a flowchart of detailed processing of the record arrangement determination unit in the embodiment of the invention.

  Step 910) The record arrangement determining unit 50 reads the test case group from the test group set storage unit 35.

  Step 920) The DB table variable of the DB definition of the test case included in the test case group is read from the test case storage unit 15.

  Step 930) When the “FROM Table ID” of the SELECT query matches the ID of the DB table variable, the DB table is added to the table in the record arrangement table memory 55 (table variable = “Table A” in the example of FIG. 15). Add SELECT query to variable reference query group.

  This process is repeated for each SELECT query of test cases belonging to the test case group.

  Step 940) The search result record count (ResultRecordCount) of each query Q1, Q2,..., Qn, Qi in the DB variable reference query group is set to Ri. The number of DB records R is R1 + R2 + ... + Rn, and R DB record variables are generated and added to the DB table variables. The number of search result records corresponds to “Result RecordCount” held by the SELECT query in the processing flow diagram of FIG.

  Step 950) Generate a record position counter on a memory (not shown) and initialize it with zero.

  Step 960) The SELECT query is registered in the record position counter of the DB table variable of the record arrangement table in the record arrangement table memory 55, and the record position counter is incremented by one.

  Specifically, a SELECT query is added to the reference query group of the DB record variable “record position counter” in the DB table variable, and a tag is assigned to the reference query group for each test case. The tag can be arbitrarily set, but for example, it can be considered to give a test case Id. Thereafter, the record position counter is incremented by one.

  The above operation will be described with reference to FIG. The queries of Q1 to Q3 are SELECT queries, and these SELECT queries refer to the DB table variable “TableA”. Q4 and Q5 are converted update queries converted into SELECT queries by the update query conversion unit 20. Since the number of search result records is one for query Q1, two for query Q2, and three for query Q3, 1 + 2 + 3 = 6 records are created in the record arrangement table memory 55 in accordance with this number.

For example, as a query:
Q1: SELECT * from TableA WHERE… ResultCount == 1
Q2: SELECT * from TableA WHERE… ResultCount == 2
Q3: SELECT * from TalbeA WHERE… ResultCount == 3
Suppose there is. In this case, the record layout pattern is
Record position counter = 1: Record [1] Record referenced by Q1;
Record position counter = 2: Record [2] Record referenced by Q2;
Record position counter = 3: Record [3] Record referenced by Q2;
Record position counter = 4: Record [4] Record referenced by Q3;
Record position counter = 5: Record [5] Record referenced by Q3;
Record position counter = 6: Record [6] Record referenced by Q3;
It becomes.

  When the processing for the number of records of the SELECT query is completed, the DB table variable (SELECT query) of the record arrangement table is reflected in the test case group set storage unit 35.

  In the above description, the record arrangement table of the record arrangement table memory 55 is used. However, it is possible to directly set the reference query group included in each record variable of the DB table variable of the test case group set storage unit 35. For example, when there are Record1 and Record2 as DB record variables, when setting queries Q1 and Q2, query Q1 can be set for Record1, and queries Q1 and Q2 can be set for Record2.

<Processing DB table variable constraint generator (step 160)>
Next, a description is given of processing of the DB table variable constraint generator 60 in step 160 of FIG. In this process, a constraint expression is generated from the DB table variable of the test case group set storage unit 35 updated by the record arrangement determination unit 50. At this time, a record that meets the conditions of the WHERE clause is generated for the record to be referenced, and a process for generating a record that does not match the conditions of the WHERE clause is performed for the record that is not referenced.

Figure 16 is a flowchart of detailed processing of the DB table variable constraint generator according to an embodiment of the present invention.

Step 1010) DB table variable constraint expression generating unit 60 reads a test case group from the test case groups set storage unit 35.

  Step 1020) A test case included in the read test case group set is extracted, and a DB table variable of the test case is read.

  Step 1030) Duplicate the WHERE clause group of the SELECT query of the DB table variable.

  Step 1040) For each “column reference” (“column reference” in the processing flow diagram of FIG. 5) included in the WHERE clause condition group duplicated in step 1030, the DB field of the DB record variable corresponding to the “column reference” Replace with a variable.

  Step 1050) If the SELECT query is included in the reference query group of the DB record variable, in order to create a logical negation of the duplicate query condition group, “duplicate WHERE clause condition group” is set to “NOT (duplicate WHERE clause condition group)”. Into a new replication query condition group. If the SELECT query is not included in the reference query group, this process is skipped.

  Step 1060) The duplicate WHERE clause condition group is added to the test case group constraint set in the test case group set storage unit 35.

  Step 1070) In the DB table variables of the test case group set storage unit 35, the DB field variables whose corresponding column type is Primary Key are F1, F2,..., Fn (n is the number of DB record variables) . A constraint expression for guaranteeing the uniqueness of Fi such as “F1 <F2 <... Fn” is generated and added to the constraint set of the test case group set storage unit 35.

The following describes the processing of the DB table variable constraint generator 60 with reference to FIG. 17.

DB table variable constraint expression generating unit 60, for the reference query for each table, to generate a reliable search results to return the number specified by the record number (ResultRecordCount) constraints. The DB table variable (record allocation table) in the test case group set storage unit 35 in FIG. 17B and the Persons table in FIG. 17A are read and specified for the reference query (SELECT) in the Persons table. Constraint expressions corresponding to the number of search result records are generated and added to the constraint set in the test case group set storage unit 35. In the example of the figure, the query Q1: “SELECT * FROM Persons WHERE Id <10 ResultRecordCount == 1, as shown in FIG. not (Age [1].> = 20) not (Q2 WHERE clause condition) ”is set.

DB table variable constraint generator 60 stores the obtained constraint above the test case set storage unit 35.

A record arrangement determination unit 50 described above, by DB table variable constraint generator 60, the SELECT each sentence, for the record to which it references, generating a record that meets the conditions of the WHERE clause, refer to not record WHERE clause A record is generated as a NOT WHERE clause so that it does not match the above conditions. This makes it possible to generate test data for testing a test case that executes the subsequent SELECT statement according to the number of records of the reference result of the immediately preceding SELECT statement. In addition, each reference access on the test path is guaranteed to return the expected number of records without excess or deficiency. As a result, it is possible to generate an initial DB state that constitutes test data for testing a test case (test path) that executes the subsequent SELECT statement according to the number of records of the reference result of the immediately preceding SELECT statement.

  The constraint equation solving unit 70 reads a constraint equation from the test case set storage unit 35, applies a constraint solver to the constraint equation, obtains a test case solution, and obtains each table variable of the test case group set storage unit 35. Add to each DB field variable of each DB record.

  The test data output unit 80 reads the test case and test data from the test case group set storage unit 35 and outputs the test case group and test path in text format. As shown in FIG. 18, the test case group includes test group group data, test group Id, DB table variable, test case (Id, flow Id, test path), DB table variable (Id, DB record variable), Includes DB record variables (Id, index, DB field variables), DB field variables (Id, integer type variable input), variables (Id, integer type variable), integer type variables (variable value).

  The operation of the constituent elements of the test data generation apparatus shown in FIG. 3 can be constructed as a program, installed on a computer used as the test data generation apparatus, 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.

1 Test Data Generation Device 2 User Terminal 10 Test Case Extraction Unit 15 Test Case Storage Unit 30 Test Case Grouping Unit 35 Test Case Group Set Storage Unit 40 Input Variable Constraint Expression Generation Unit 50 Record Placement Determination Unit 55 Record Placement Table Memory 60 DB Table Conversion constraint equation generation unit 70 Constraint equation solution unit 80 Test data output unit

Claims (9)

A test data generation device having a plurality of reference accesses in a test path for generating test data having a plurality of reference accesses to a database (DB) during the test path,
A test case extraction means for extracting a test case from the inputted design information and storing it in the test case storage means;
The test cases are read from the test case storage means, and test cases that can share the same initial DB state are grouped as test case groups so that there is no duplication in the records extracted by each SELECT statement of test cases belonging to the same group. , Test case grouping means for storing in the test case group set storage means,
The test case group is read from the test case group set storage means, a constraint expression of the input variables of the test cases of the test case group is generated, and stored in the constraint set of the test case group set storage means including the test case. Input variable constraint expression generation means;
Obtaining the test case group from the test case group set storage means, obtaining a DB table variable of a test case included in the test case group from the test case storage means , determining a record number of the DB table variable; The process of adding a SELECT query to the reference query group of the DB table variable is repeated for the number of records , added to the reference query group of the DB table variable of the record arrangement table storage unit, and the DB of the record arrangement table storage unit Record placement determining means for reflecting table variables in the test case group set storage means ;
For the DB table variables included in the test case a group of the test case group set storage unit, generates a constraint equation to ensure uniqueness, and DB table variable constraint expression generating means for storing in the test case groups set storage unit ,
Constraint equation solving means that solves the constraint expression stored in the test case group set storage means using an arbitrary solution and outputs the input value for each test case and the DB initial state sharing the test case as test data When,
A test data generation apparatus having a plurality of reference accesses in a test path. The test case grouping means includes:
The test path according to claim 1, further comprising means for arbitrarily selecting one test case from the test cases to be grouped and substituting the DB table variable of the selected test case into the DB table variable of the test case group. A test data generator with multiple reference accesses. The record arrangement determining means is
2. The test data generation apparatus having a plurality of reference accesses in a test path according to claim 1, further comprising means for setting the number of records as a total value of the number of search result records of each reference query. The DB table variable constraint expression generating means,
A means for generating a record that meets a condition of a WHERE clause referred to by a SELECT statement of the DB table variable of the record arrangement table storage unit , and a record that generates a record so that a record that is not referred to does not match a condition of the WHERE clause. A test data generation apparatus having a plurality of reference accesses in one test path. A test data generation method having a plurality of reference accesses in a test path for generating test data having a plurality of reference accesses to a database (DB) during the test path,
Test case storage unit, the test case group set storage unit, the test case extraction means, test case grouping means, the input variable constraint expression generation unit, the record arrangement determining means, DB table variable constraint expression generating means, devices having a constraint solver In
The test case extraction means extracts a test case from the inputted design information and stores it in the test case storage means;
The test case grouping unit reads the test case from the test case storage unit, and the test cases that can share the same DB initial state are not duplicated in the records extracted by the SELECT statements of the test cases belonging to the same group. A test case grouping step for grouping as test case groups and storing them in a test case group set storage means;
The input variable constraint expression generation unit acquires the test case group from the test case group set storage unit, acquires a DB table variable of a test case included in the test case group from the test case storage unit, and An input variable constraint expression generating step of generating a constraint expression of a case input variable and storing it in a constraint set of the test case group set storage means including the test case;
The record arrangement determining means acquires the test case group from the test case group set storage means, acquires a DB table variable of a test case included in the test case group from the test case storage means , and the DB table variable of determining the number of records, the process of adding a SELECT query to see query group of the DB table variable, the record number of items repeated, adding to the reference query group of the DB table variable record arrangement table storage means, the record A record placement determination step of reflecting the DB table variable of the placement table storage means in the test case group set storage means ;
The DB table variable constraint expression generating means for the DB table variables included in the test case a group of the test case group set storage unit, generates a constraint equation to ensure uniqueness, to the test case group set storage unit and DB table variable constraint expression generation step of storing,
The constraint equation solving means solves the constraint expression stored in the test case group set storage means using an arbitrary solution, and inputs test values for each test case and the DB initial state sharing the test case. A constraint solution step to output as
A test data generation method having a plurality of reference accesses in a test path. In the test case grouping step,
6. A plurality of references in a test path according to claim 5, wherein one test case is arbitrarily selected from the test cases to be grouped, and the DB table variable of the selected test case is substituted into the DB table variable of the test case group. Data generation method for the test with access. In the record arrangement determining step,
6. The test data generation method having a plurality of reference accesses in a test path according to claim 5, wherein the number of records is the total value of the search result records of each reference query. In the DB table variable constraint expression generation step,
6. The record according to claim 5, wherein a record that satisfies a condition of a WHERE clause referenced by a SELECT statement of the DB table variable of the record arrangement table storage unit is generated, and a record that is not referred to is generated so as not to match the condition of the WHERE clause. A data generation method for testing with multiple reference accesses in the test path. Computer
A test for having a plurality of reference accesses in a test path for functioning as each means of a test data generating apparatus having a plurality of reference accesses in a test path according to any one of claims 1 to 4. Data generation program.

Images