JP5514143B2 - Test data generation apparatus and method - Google Patents

Description

  The present invention relates to a test data generating apparatus and method, and more particularly to automatically generating test data for performing a test for confirming the operation of a program when business logic and a database (DB) are combined. The present invention relates to a test data generation apparatus and method.

  In general, the integration test, which is a test for confirming the operation when the business logic and DB are combined, differs from the unit test performed by replacing a part of the program with a controllable dummy (stub, mock). Because it is a test target, the inside of the program cannot be modified. For this reason, in order to cause the behavior of the program to be confirmed by the test, it is necessary to provide an appropriately set parameter to the test target program from the outside. However, it takes time and labor to prepare the input value to the business logic and the initial value of the DB record manually, which is not efficient.

  As the first technology to automatically generate test data, input data definition and processing flow are used as input, and test data is generated by generating integer type and string type input values for passing through a specific test path. (For example, refer nonpatent literature 1).

  As a second technique, there is a method of generating a DB initial state (mainly for performance test) that satisfies a DB definition and has a specified number of records by using the DB definition as an input.

  As a third technique, there is a method of generating an input value and a DB initial state using an input value definition, a DB definition, and a DB precondition as inputs (see, for example, Non-Patent Document 2).

Akira Zhang, Takashi Hoshino "Test Item Extraction and Test Data Generation Method Using Design Model", IEICE Tech. Bulletin, Volume 109 of SS2009-7. Pp.37-42. 2009. Shoichiro Fujiwara, Kazuki Munakata, Asako Katayama, Yoshiharu Maeda, Kenji Oki, Tadahiro Uehara, Rieko Yamamoto. Generation of test data for web applications using Smt solver. Proceedings of the IPSJ 50th Anniversary (72nd) National Convention. 2010.

  However, the first conventional technique cannot generate data in the initial DB state (DB table type). In addition, since the DB search condition is not read from the design document, there are omissions in the constraints that the input value and the DB initial state must satisfy in order to pass a specific test pass. In addition, there is a problem that appropriate test data cannot be generated when there is a complicated data structure (array) or complicated interdependency of variables.

  Even if the conventional first and second technologies are used in combination, the DB search condition is not handled as design information, and therefore, branching of processing depending on the number of DB record search results is controlled. Test data cannot be generated. In the second technique, there is a method of generating the input value and DB initial state separately and repeating until the number of search results falls within the range specified by the upper limit value and lower limit value. There is a problem that it cannot be solved.

  In the third technique, since a flow diagram cannot be handled, it is not possible to generate an input value and a DB initial state that pass a specific test path. Furthermore, there are omissions due to indispensable restrictions on the DB initial state (for example, restrictions on the primary key). In addition, there is a problem that the inclusion relation between character string variables cannot be handled.

  The present invention has been made in view of the above points. A test data generation apparatus that generates input of software design information such as an input value definition, a process flow diagram, and a DE definition, and generates test data that can control the branch of the process, and An object is to provide a method and a program.

In order to solve the above problems, the present invention is a test data generation device that generates test data for performing a functionality test that involves a read operation of data stored in a database (DB),
Test case storage means for storing test cases;
As design information, an input value definition that represents a domain of software input values, a process flow diagram that represents the flow of software processing, a DB definition that is database design information is acquired, input variables, DB table variables, and the software A test case extracting means for extracting a constraint that is a condition to be satisfied by the test data so as to cause a specific behavior of the test case, and storing it in the test case storage means;
Solving the restriction on the number of records of the DB table variable obtained from the test case storage means, determining the number of records of the DB table variable, and storing the number of DB records stored in the test case storage means;
Deriving constraints on the string length from the constraints on the inclusion relationship between the string type variables obtained from the test case storage means, solving the constraints on the string length of the string type variable and the integer type variable, and the string length Integer / character string length determining means for storing variables and integer variables in the test case storage means;
Character determination means for solving restrictions on the character string type variable, determining values of characters constituting the character string type variable, and storing them in the test case storage means;
Output means for outputting the input variables and the DB table variables stored in the test case storage means as test data.

The test case extraction means includes
Extract “constraints on input values” from the input value definition and the processing flow diagram, and extract “constraints on the number of search hits, input values, DB initial state dependency” from the DB search conditions of the processing flow diagram, Means for extracting “constraints on the initial DB state” from the DB definition;

The record number determining means is
When a complex DB table record group corresponding to a nested array is detected, the “DB table record group represented by the inequalities included in the“ restrictions regarding the number of search hits, input values, and DB initial state dependency ” Including the means to determine the number of DB records in the DB table variable by selecting `` Restriction on number of cases '' and solving as simultaneous inequalities,
The integer / character string length determining means includes:
When a record group of a complicated DB table corresponding to a nested array is detected, the “constraints on input values” extracted by the test case extraction unit, the “number of search hits, input values, DB initial state dependency” ”Restriction on DB” and “Restriction on DB initial state”, select “Constraint on length of character string” expressed by inequalities, and determine the length of the array by solving as simultaneous inequalities Including means.

The record number determining means is
A means for selecting a constraint relating to the primary key and foreign key of the DB record from the “constraints on the DB initial state” and transforming the constraint into a comparison between integer variables or a comparison between character string variables;

The integer / character string length determining means includes:
Select constraints on the primary key and foreign key of the DB record from the “constraints on the DB initial state” and convert them into comparisons between integer variables, the “constraints on input values”, the “number of search hits, input values” , Constraints on DB initial state dependency ”and“ Constraints on DB initial state ”, select“ integer constraints ”expressed by inequalities, and solve constraints on selected integers as simultaneous inequalities And means for obtaining a value satisfying the constraint group.

The character determining means includes
Correspondence between the character string variables based on the inclusion relationship between the character string variables included in any one of the “restrictions on input values” and “restrictions on the number of search hits, input values, and DB initial state dependency” Means for determining a character that matches each of the characters existing at the position to be the value of the character.

  As described above, according to the present invention, the conditions to be satisfied by the test data for controlling the branch of the process are extracted from the design information as a constraint group to be solved in the constraint satisfaction problem, and aggregated, so that A combination of an input value and a DB initial state that can control branching can be specified within a practical time.

  In the present invention, even with software including a complicated data structure such as a nested array, test data can be appropriately generated.

  Also, test data that handles complex interrelationships of variables such as comparison between integer variables and inclusion relations between character string variables (equivalent, forward match, partial match, backward match) can be generated.

It is an example of the flowchart used by this invention. It is an example of the test path | pass used by this invention. It is an example of the input value definition used by this invention. It is an example of DB definition used by this invention. It is an example of the restrictions used by the present invention. It is a figure which shows the definition of the restrictions used by this invention. It is a block diagram of the test data generation device in one embodiment of the present invention. It is the data stored in the test case memory | storage part in one embodiment of this invention. It is a flowchart of the whole process of the test data generation apparatus in one embodiment of this invention. 10 is a detailed flowchart of S110 in FIG. 9 according to an embodiment of the present invention. It is a flowchart of the route list production | generation process in one embodiment of this invention. It is a detailed flowchart of S206 of FIG. 11 in one embodiment of this invention. It is a detailed flowchart of S211 of FIG. 11 in one embodiment of this invention. FIG. 11 is a detailed flowchart of S240 in FIG. 10 according to an embodiment of the present invention. It is an example of conversion from DB search conditions to constraints in one embodiment of the present invention. FIG. 10 is a detailed flowchart of S120 in FIG. 9 according to an embodiment of the present invention. It is a detailed flowchart of S370 of FIG. 13 in one embodiment of this invention. It is a detailed flowchart of S380 of FIG. 13 in one embodiment of this invention. 10 is a detailed flowchart of S130 in FIG. 9 according to an embodiment of the present invention. It is an example of the process which determines the character string length in one embodiment of this invention. It is a character string comparison operator table in one embodiment of the present invention. It is a detailed flowchart of S450 of FIG. 15 in one embodiment of this invention. FIG. 10 is a detailed flowchart of S140 in FIG. 9 according to an embodiment of the present invention. It is a figure which shows the process of the character determination part in one embodiment of this invention. FIG. 21 is a detailed flowchart of S540 in FIG. 20 according to an embodiment of the present invention. It is a detailed flowchart of S1070 of FIG. 22 in one embodiment of this invention.

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

  First, terms used in this specification will be described.

  Process flow diagram: A type of software design information, representing behavior (flow of software processing). There are various types of processing flow diagrams such as flowcharts and UML (Uniformed Modeling Language) activity diagrams. An example of a processing flow diagram is shown in FIG. The processing flow diagram includes a processing flow diagram composed of nodes and edges, nodes, node contents, DB search conditions, number of search result records, Where clause condition group, next node connection edge group, edge, and guard condition.

  Test path: A specific path in the processing flow diagram. In order to ensure route coverage, it is necessary to create appropriate test data that passes the test paths for all test paths in the process flow diagram. An example of the test path is shown in FIG. The test path consists of node and edge information.

  Input value definition: A type of software design information that represents the domain of software input values. An example of the input value definition is shown in FIG.

  DB definition: Database design information, which describes the table name, column name in each table, column type, and domain of the column value. An example of the DB definition is shown in FIG. The DB definition includes the definition target DB table, DB table record, column, type and domain, integer domain, character string definition, column type, and reference column.

Constraint: One of a plurality of conditions to be satisfied by test data that can cause “specific behavior of software”. As shown in FIG.
(1) Constraints on input values: Obtained from input value definition and processing flow diagram;
(2) Restrictions on correspondence between search hit count, input value, and DB initial state: Acquired from DB search conditions described in the processing flow diagram;
(3) Restrictions on DB initial state: Obtained from DB definition;
Each constraint included in the above (1) to (3) is defined by BNF as shown in FIG. The constraints include a constraint (FIG. 6A) extracted by a test case extraction unit (described later) included in the design information and a constraint derived during the test data generation process (FIG. 6B). The constraints include integer constraints, character string constraints, and unique constraints. Integer constraints include constraints on integer arithmetic expressions, integer comparison operators, and integer arithmetic expressions. The string constraints include constraints on string factors, string comparison operators, and string factors. Unique constraints are represented by distinct references to distinct columns.

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

  The test data generation device 100 is connected to the user terminal 10.

  The test data generation apparatus includes a test case extraction unit 110, a DB record number determination unit 120, an integer / character string length determination unit 130, a character determination unit 140, a test data output unit 150, and a test case storage unit 160.

  Among the above configurations, the test case extraction unit 110, the DB record number determination unit 120, the integer / character string length determination unit 130, the character determination unit 140, and the test data output unit 150 function in the CPU, and the test case storage unit Reference numeral 160 denotes a storage medium such as a memory or a hard disk.

  The test case extraction unit 110 acquires design information in XML format from the user terminal 10, extracts input variables, DB table variables, and constraints from the design information, and stores them as test cases a in the test case storage unit 160. Test case a is a process flow diagram of design information in FIG. 1, test path in FIG. 2, input value definition in FIG. 3, DB definition in FIG. 4, extracted input variables, DB table variables, constraints (FIG. 6 (A ))including.

  The DB record number determination unit 120 reads the test case a from the test case storage unit 160, determines the value of the number of DB records from the DB table variable included in the test case a, copies the test case a, A value obtained by setting the record number of the DB table variable as a member is set as a test case b, and the test case b is stored in the test case storage unit 160. In addition, constraints on DB table variable columns are expanded for each record field.

  The integer / character string length determination unit 130 reads the test case b (constraint on the inclusion relationship between variables and character strings (FIG. 6A)) from the test case storage unit 160 and relates to the inclusion relationship between character string type variables. The constraint on the character string length (Fig. 6 (B)) is derived from the constraint, the constraint on the character string length of the character string type variable and the constraint on the integer type variable (Fig. 6 (A)) are solved, and their values (character string) (Type variable, character string length variable, integer type variable) are determined, and the contents obtained by copying these values and test case b are set as test case c, and the test case c is stored in the test case storage unit 160.

  The character determination unit 140 reads the test case c from the test case storage unit 160, solves the restriction on the character string type variable (FIG. 6A), determines the value of the character constituting the character string type variable, The content copied from the value and the test case c is set as a test case d, and the test case d is stored in the test case storage unit 160.

  The test data output unit 150 outputs the values of input variables and DB table variables from the test case storage unit 160 to the user terminal 10 in text format.

  The test case storage unit 160 stores test cases, character string inclusion relation trees, character string parent / child nodes, constraints shown in FIG. 6, and the like as intermediate data output from each of the above-described configurations as shown in FIG. From the test case extraction unit 110, {constraint, variable} is stored as the test case a. The DB record number determination unit 120 stores {test case a + DB table variable, DB record number variable, DB record variable, DB field variable} as the test case b. Integer / character string length determination unit 130 stores {test case b + character string type variable, character string length variable, integer type variable, character string inclusion relation tree, character string parent-child node} as test case c. Character test unit 140 stores {test case c + character variable, value determined variable} as test case d.

  The operation in the above configuration will be described in detail below.

  First, the overall operation of the test data generation apparatus 100 will be described.

  FIG. 9 is a flowchart of the overall processing of the test data generation device according to one embodiment of the present invention.

Step 110) The test case extraction unit 110 acquires design information. Design information
DB definition (DB table variables, constraints on each column of DB table, DB table primary key, foreign key);
・ Input value definition;
・ Processing flow diagram;
Is included. Variables (input variables, DB table variables) and constraints are extracted from the design information and stored in the test case storage unit 160 as test cases a. Details of this step will be described later with reference to FIG.

  Step 120) In the DB record number determination unit 120, the test case a is read from the test case storage unit 160, the restriction on the number of records in the DB table variable is solved, the number of records in the DB table variable is determined, and the DB and table variable columns Is expanded to the field of each record, test case a is copied, the value set to the number of records of the DB table variable that is the member is set as test case b, and the test case b is set as the test case Store in the storage unit 160. The test case b is stored in the test case storage unit 160. Details will be described later with reference to FIG.

  Step 130) In the integer / character string length determination unit 130, the test case b is obtained from the test case storage unit 160, the constraint on the character string length is derived from the constraint on the inclusion relation between the character string type variables, and the test case storage unit After adding to the constraint set of 160, the constraints on the character string length of the character string type variable derived in step 120 and the integer type variable extracted in step 110 are solved, and the respective values are determined. The test case b is copied, and the value set for the character string length variable of the character string type variable and the value of the integer type variable is stored in the test case storage unit 160 as the test case c.

Step 140) Acquire test case c from the test case storage unit 160, and the character determination unit 140 resolves the restrictions on the character string type variable, determines the value of the character constituting the character string type variable, and copies the test case c And stored in the test case storage unit 160 as a test case d.
Details will be described later with reference to FIG.

  Step 150) The test data output unit 150 obtains the values of the input variables (FIG. 8, 9th line) and the DB table variables (FIG. 8, 5th line) from the test case d of the test case storage unit 160, and the user terminal Dump output to 10.

  In steps 120 and 130 described above, when a complicated data structure (DB table record group, character string) corresponding to the nested array is detected, the length of the “outside” array (DB table record) Select constraints from the conditions (1), (2), and (3) shown in FIG. 5 for the constraints on the number of groups and the length of the character string, and solve them by prioritizing them. Determine the length.

  Next, processing for extracting variables and constraints from the design information in the test case extraction unit 110 in step 110 will be described.

  FIG. 10 is a detailed flowchart of S110 in FIG. 7 according to the embodiment of the present invention.

  Step 210) The test case extraction unit 110 reads the DB definition (FIG. 4) from the design information, and extracts variables and constraints. More specifically, a DB table variable and a constraint ((3) in FIG. 5) for each column of the DB table are extracted from the DB definition, and the variable and the constraint are output.

  Step 220) Next, the input value definition (FIG. 3) is read from the design information, and variables and constraints are extracted. Specifically, the input variable and the constraint on the input value (FIG. 5, (1)) are extracted from the input value definition.

  Step 230) Next, the processing flow diagram (FIG. 1) is read, and all test paths (FIG. 2) are extracted so as to satisfy the C1 coverage. Here, a test path extraction method will be described. The test path extraction is executed by a route extraction function provided in the test case extraction unit 110.

  The route extraction function generates a list of routes that pass through the number of loops specified by the maximum number of loop passes in order to extract the execution route to be tested from the read flow diagram.

  The route extraction function reads all node information (node ID, text in node, next developed edge group) and edge information (edge ID, start point connection node ID, end point connection node ID, transition condition) in the flow diagram, and routes Generate a list. The route list generation process is shown below.

  FIG. 11 is a flowchart of route list generation processing according to the embodiment of the present invention.

  Step 2010) The path extraction unit 130 loads the read start edge on the next developed edge group stack. It is assumed that the path extraction function includes an internal buffer and a stack area is provided in the buffer.

  Step 2020) It is determined whether or not the next developed edge group stack is empty. If it is empty, the process is terminated.

  Step 2030) It is determined whether or not there is an element in the next development edge group at the top of the next development edge group stack.

  Step 2040) One edge is obtained from the element at the top of the next development edge group stack (currently next development edge group) to be the current edge.

  Step 2050) Remove the current edge from the current next developed edge group.

  Step 2060) Calculate the number of loop appearances in the path (a sequence of edges stacked in the edge stack). This process calculates the number of current loop routes (number of loop appearances) existing in the search route. Details of this processing will be described later with reference to FIG.

  Step 2070) If the number of appearances of the loop (the maximum number of appearances of the loop) is larger than the value obtained by adding 1 to the user-specified maximum number of loops input from the user terminal 10, the process proceeds to Step 2020. The processing is to terminate the search of the route when the maximum number of occurrences of the loop in the route being searched exceeds the abnormal value (maximum number of user-specified loop passages + 1). The “maximum number of appearances of the loop” is the number of appearances of the loop path having the maximum number of appearances of the loop among the plurality of loop paths included in the search route.

  Step 2080) The current edge is stacked on the edge stack, and the loop appearance count is stacked on the loop appearance count stack.

  Step 2090) Based on the end node ID of the current edge, a node is acquired from the flow diagram, an edge (connection to the start point) group of the node is acquired, and the acquired edge (connection to the start point) group is Then, the next development edge is stacked on the next development edge group stack.

  Step 2100) If the current edge is not connected to the end node, go to Step 2020.

  Step 2110) According to the maximum number of occurrences of the loop of the route, an upper limit value, an abnormal value, a neighborhood value, and a label are assigned, and a route (a sequence of edges stacked on the edge stack) is output. Further, a route that does not correspond to any of the upper limit value, the abnormal value, and the neighborhood value is not output. Details of this processing will be described later with reference to FIG.

  Step 2120) Pop the stack for the next development edge group.

  Step 2130) If the popped edge stack is empty, the process ends.

  Step 2140) The edge stack and the loop appearance number stack are popped, and the process is terminated.

  Next, the process of calculating the number of appearances of the current loop path in the path of step 206 in FIG. 11 (the row of edges stacked on the edge stack) will be described in detail.

  FIG. 12 is a detailed flowchart of S2060 in FIG. 11 according to the embodiment of the present invention.

  Step 3010) The path extraction function reads the current edge from the buffer.

  Step 3020) A route (a sequence of edges stacked on the edge stack) is read.

  Step 3030) A search route is generated. Specifically, the route is duplicated, and the duplicated route is set as a search-in-progress route.

  Step 3040) It is calculated how many times the current loop path appears from the head of the search path to the current edge closest to the head.

  Step 3050) Find out how many times the current loop route appears in the mid-search route (the number of loop appearances). As a technique for obtaining the number of occurrences of the loop, techniques such as “R.S. boyer: J. S. Moore (1997).“ A fast string searching algorithm ”. Comm. ACM 20: 762-772” can be used. The technique of Document 1 is an algorithm for character string matching, but can be applied if one edge is regarded as one character and a path (edge string) is regarded as a character string.

  Next, the processing for outputting the contents of the edge stack in step 2110 of FIG. 11 as a route will be described in detail.

  FIG. 13 is a detailed flowchart of step 2110 in FIG. 11 according to the embodiment of the present invention.

  Step 4010) The route extraction function calculates the maximum number of loop occurrences of the route. Specifically, the maximum value of the number of loop appearances stacked in the loop appearance number stack is acquired and set as the maximum number of loop appearances.

  Step 4020) It is determined whether the maximum loop appearance count (M) and the user-specified maximum loop passage number (N) are equal (M = N). If they are equal, the process proceeds to Step 4030, and if they are not equal, the process proceeds to Step 4040. To do.

  Step 4030) In the case of M = N, an “upper limit value” label is assigned to output the route, and the process is terminated. If M = N, the process proceeds to step 4040.

  Step 4040) If the maximum number of occurrences of the loop is equal to the value obtained by adding 1 to the user-specified loop maximum number of passes (M = N + 1), the process proceeds to step 4050, and if not equal, the process proceeds to step 4060.

  Step 4050) If M = N + 1, an “abnormal value” label is assigned to output the route, and the process is terminated.

  Step 4060) If the maximum number of occurrences of the loop is equal to the value obtained by subtracting 1 from the maximum number of loops specified by the user (M = N-1), the process proceeds to Step 4070, and if not equal, the process ends.

  Step 4070) When M = N−1, a “neighbor value” label is assigned to output the route, and the process is terminated.

  Returning to the description of the processing in FIG.

  Step 240) Next, from the test path extracted from the process flow diagram, the constraint on the input value (FIG. 5 (3)) and the constraint described in the DB search condition of the process flow diagram (FIG. 5 (2)) are extracted. To do. Set “input condition tag” in the constraint type tag of the constraint for the input value. “Restriction condition tag” is set as the restriction type tag of the restriction described in the DB search condition. The process of extracting constraints from the test path will be described later with reference to FIG.

  Step 250) The variables and constraints extracted in the above Steps 210, 220 and 240 are acquired, a test case (original test case) a having a set of constraints as a member is created and stored in the test case storage unit 160. Store.

  Next, processing for extracting constraints from the test path in step 240 will be described.

  FIG. 14 is a detailed flowchart of S240 in FIG. 10 according to the embodiment of the present invention, and FIG. 15 shows an example of conversion from DB search conditions to constraints.

  First, the following processing is performed for each node in the test path.

  Step 600) The test case extraction unit 110 determines whether each node of the test path extracted in Step 230 has a DB search condition with reference to the processing flow diagram (FIG. 1). If not, the process proceeds to the next node.

Step 610) If there is a DB search condition in the node, “restrictions in the Where clause condition group” of the DB search condition are extracted. In the example of FIG. 15, design information
WHERE (ID> = search ID)
AND (name subString employee name)
Is extracted.

  Step 620) Min count (Fig. 1), Min Count <= Count (From TableId) constraint, Max Count (Fig. 1), MAX> = Count (From Convert to TableId) constraint and output.

  The process so far is repeated for the number of nodes.

  Next, the following processing is performed on each edge of the test path.

  Step 630) Next, as processing for each edge of each test path, it is determined whether there is an edge guard condition with reference to the process flow diagram of the test case a (FIG. 1). Extract constraints (integer constraints, string constraints). This process is performed for each node in the test path.

  From the above processing, the number of search hits, the input value, the constraint on the dependency on the DB initial state, and the constraint on the DB initial state are extracted. As a result, the conditions (FIGS. 5 (1), (2), and (3)) that can control the branching of the processing are extracted from the design document without omission and are aggregated. Can be solved with existing technology.

  Next, a process of determining the value of the number of DB records in step 120 in FIG. 9 in the DB record number determination unit 120 will be described.

  FIG. 16 is a detailed flowchart of S120 in FIG. 9 according to the embodiment of the present invention.

  Step 310) The DB record number determination unit 120 reads the test case a from the test case storage unit 160.

  Step 320) A default value for the number of DB records designated by the user is acquired, and the processing up to Step 370 is performed for each DB table variable of the test case. It is assumed that the default value is stored in advance in a memory (not shown).

  Step 330) The DB table variable and the constraint set included in the test case a read in Step 310 are acquired, and all the constraints including the record number reference are acquired and output. In the example of FIG. 6, “record number reference = Count (DB table variable)” is output.

  Step 340) If there are one or more constraints on the number of records, the constraints on the record number variable of the DB record variable and the DB table variable are acquired from the test case constraint set shown in FIG. In the example of FIG. 8, “DB record variable = Id DB field variable +” and “DB record number variable = Id integer variable” are acquired. Solve the restrictions on the number of DB records in the DB record variable, and determine the value of the record number. At this time, since the constraints on the number of records in the DB record variable are integer inequalities, these are simultaneous and solved as simultaneous inequalities using existing technology (SMT Arithmetic Theory, Simplex method). Find the value. Control goes to step 360.

  Step 350) If there is no restriction on the number of records in the restriction set, the user-specified DB record number default value is set as the value of the number of records. At this time, the constraint on the input variable (FIG. 5 (3)) and the constraint described in the DB search condition (FIG. 5 (2)) are extracted from the test path included in the test case.

  Step 360) A DB table variable is acquired from the test case area of the test case storage unit 160, DB record variables are generated for the value of the DB table variable, and added as members of the DB table variable in the test case area.

  Step 370) The constraint set is acquired from the test case storage unit 160, and the constraint on the column of the DB table (FIG. 6A, “column reference”) is expanded as a constraint on the DB field variable. At this time, a constraint (FIG. 6A) including the column generic reference (∀) is selected and expanded as a constraint on the DB field variable (FIG. 8). Details will be described later with reference to FIG.

  Step 380) The constraint set is acquired from the test case storage unit 160, and the constraint on the foreign key is added to the constraint set of the test case storage unit 160. At this time, constraints including column presence references are selected and expanded as constraints on DB field variables. Details will be described later with reference to FIG.

  The process of expanding the constraint on the DB table column in step 370 of FIG. 16 as a constraint on the DB field variable will be described.

  FIG. 17 is a detailed flowchart of S370 in FIG. 16 according to the embodiment of the present invention.

  Step 710) The DB record number determination unit 120 acquires a constraint set and selects a constraint including a column generic reference.

  Step 720) If the constraint selected in Step 710 is not a unique constraint, the constraint on the DB table column is expanded as a constraint on the DB field variable. At this time, it is limited by the value of the DB record number variable (see FIG. 6A) “Refer record number” of the DB table variable corresponding to the DB table referenced in the column generic reference (FIG. 6A). Duplicate. Then, the column generic reference portion of the copied constraint is replaced with the DB field variable corresponding to each DB record variable column held by the DB table variable, and the constraint including the DB field variable is output.

  Step 730) When the constraint including the column generic reference selected in Step 710 is a unique constraint, and the column type is an Int type (integer type), the integer type unique constraint is expanded as a constraint on the DB field variable. To do. At this time, for the unique constraint “distinctfieldcolumX”, columX and DB field variables are fieldX1, fieldX2,. An integer constraint of fieldXi> fieldX (i + 1) (where i = 1 to n−1) is generated, and an integer constraint of the form x <y is output.

  Step 740) When the constraint selected in Step 710 is a unique constraint and the column type is a String type (character string type), the character string type unique constraint is expanded as a constraint on the DB field variable. At this time, a string constraint of "id1 subString c1, id1 subString c2, ..., idn substring cn" is added to each DB field variable (string type) corresponding to the column, and the form "x substring c" Outputs the string constraints for. Here, c1 to cn are constant character strings, and the values of the character strings are determined so as to be unique. For example, c1 = "01", c2 = "02", etc. may be set.

  Next, the process for adding a constraint relating to the foreign key in S380 in FIG. 16 will be described.

  FIG. 18 is a detailed flowchart of S380 according to the embodiment of the present invention.

  Step 810) The DB record number determination unit 120 reads the test case a from the test case storage unit 160.

  Step 820) Select a constraint including a column existence reference from the constraint set included in the test case a.

Step 830) When the column type of the constraint including each column existence reference (∃) is Int (integer type) (FIG. 6A), the constraint on the foreign key is expanded as the constraint on the DB field variable, and x = Output integer constraints of the form = y. Here, expanding the constraint means that DB field variables corresponding to columX and columY are respectively set to the constraint that ∃columX == ∃columY related to the input integer type foreign key.
fieldX1, FieldX2,…, fieldXn, filedY1, fieldY2,…, fieldXm
And Here, an integer constraint of fieldXi == any FieldY (where i = 1 to m or any FieldYm) is generated and transformed into a constraint of comparing integer variables.

Step 840) If the column type of the constraint including each column presence reference is String type (character string type) (FIG. 6A), the constraint on the foreign key of the string type is expanded as the constraint on the DB field variable. . The expansion of this constraint means that DB field variables corresponding to columX and columY for the constraint of ∃columX == ∃columY related to the input string type foreign key,
fieldX1, fieldX2,…, filedXn, fieldY1, fieldY2,…, fieldXm
And Here, an integer constraint of fieldXi equalsString anyFieldY (where i = 1 to m, anyFieldY is any of fieldY1 to fieldYm) is generated and transformed into a constraint of comparing character string variables.

  Of the constraints included in the condition (3) in FIG. 5 (constraints on the DB initial state) of the above-mentioned DB record number determination unit 120, constraints on the primary key and foreign key of the DB record are selected, and comparison between integer variables is performed. By transforming into a constraint of a kind of comparison between character string variables, primary key and foreign key constraints are converted into constraints of comparison between integer variables and comparison between character string types. Since it is solved in combination with the constraints of the conditions (1) and (2) in FIG. 5, it is possible to generate a DB initial state value that satisfies the DB definition and can control the branch of processing.

  Next, the processing of S130 in FIG. 9 of the integer / character string length determination unit 130 will be described.

  FIG. 19 is a detailed flowchart of S130 in FIG. 9 according to the embodiment of the present invention.

  Step 410) The integer / character string length determination unit 130 reads the test case b from the test case storage unit 160.

  Step 420) From the constraint set included in the acquired test case b, a character string constraint related to the inclusion relationship between the character string type variables is selected. An example of character string restriction is shown in FIG.

  Step 430) A character string inclusion relation tree is created in which the left character string factor in the character string constraint selected in Step 420 is a character string parent node and the right character string factor is a character child node. The child operator group of character string operators is arranged in the order in which the character string operators are registered as a forward match, partial match, backward match, and equivalent in the character string comparison operator table shown in FIG. Create An example of the character string inclusion relation tree list is shown in FIG.

  Step 440) When the character string inclusion relation tree list is acquired, an empty list is generated, and each character string inclusion relation tree list is searched in depth-first order, and each character string parent and child node is put in the list. Create a string parent-child node list. An example of the character string parent-child node list is shown in FIG.

Step 450) The restriction on the character string length of the character string variable is extracted from the character string parent-child node list generated in Step 440. An example of extraction is shown in FIG. In the example of FIG. 20, the relationship between the character string lengths of the character strings C and D in FIG. 20C is C> = D, and the relationship between the character string lengths of the character strings A, B, and C is A> = C + B. Yes, because the relationship between the character string lengths of character strings E and F is E = F.
Length (A)> = Length (C) + Length (B)
Length (C)> = Length (D)
Length (E) == Length (F)
Is obtained (FIG. 6B). This process is performed for each character string parent-child node in the list of character string parent-child nodes. Details will be described later with reference to FIG.

  Step 460) From the above constraint set, select all the integer constraints (the constraints relating to the character string length are also included because they are integer constraints).

  Step 470) Since the selected integer constraint is an integer inequality, it is solved as a simultaneous inequality using existing technology (SMT Arithmetic Theory, simplex method), and the value of the number of records satisfying the constraint is obtained. In addition to the simplex method, SMT, Solver, etc. may be used. Since these solutions are fast, you can solve the constraints in a practical time and specify the combination of the input value and DB initial state.

  Next, the operation of step 450 will be described.

  FIG. 22 is a detailed flowchart of S450 of FIG. 19 in one embodiment of the present invention.

  Step 910) The integer / character string length determination unit 130 reads the character string parent-child node list generated in step 440.

  Step 920) The character string child of the node group by the character string comparison operator in which the character string factor of the character string parent / child node of the read character string parent / child node list is s0 and the character string comparison operator belongs to the equivalent of the character string comparison operator table. Let s1 be the string factor of the node. An integer constraint of Length (s0) == Length (s1) is generated for all string child nodes.

Step 930) Next, a character string length constraint (FIG. 6A) regarding partial matching between character strings is extracted. Specifically, of the character string parent and child nodes read in step 910, the character string factor of the character string parent node is s0, and the character string comparison operator is included in the forward match of the character string comparison operator table (FIG. 21). The character string factor of the character child node of the node group classified by the character string comparison operator is sh. S1, s2,..., Sn are the character string factors of the character string child nodes of the node group by character string comparison operator included in the partial match of the character string comparison operation table. The string factor of the string child node of the node group by the string comparison operator included in the forward match of the string comparison operator table is set as st
Length (s0)> = Length (sh) + Length (s1) +… + Length (sn) + Length (st)
The integer constraint is generated and output as an integer constraint relating to the character string length (FIG. 6B).

  By determining the length of the array in order from the array outside the nesting by the processing of the integer / character string length determination unit 130, the constraint on the integer is finally solved as a simultaneous inequality, and the array Thus, it is possible to appropriately generate test data for a complicated data structure (nested array) that is divided and managed.

  In addition, by extracting all the restrictions on the length of the character string, the length of the character string can be obtained first and can be solved by the character determination unit 140, so that the inclusion relationship between the character strings is satisfied. Test data can be generated.

  Next, the process of S140 of FIG. 9 in the character determination unit 140 will be described in detail.

  FIG. 23 is a detailed flowchart of S140 of FIG. 9 in one embodiment of the present invention, and FIG. 24 shows the processing of the character determination unit in one embodiment of the present invention.

  Step 510) The character determination unit 140 selects a character string type variable from the variable set of the test case c read from the test case storage unit 160.

  Step 520) A character string type variable is generated for the value of the character string length variable of the character string type variable selected in step 520, and is made a member of the character string type variable. Symbols of character string type variables are assigned unique symbols (“σ1” and “σ2” in FIG. 24) that are different in all character string type variables (FIG. 24A).

  Step 530) The character string parent / child node list (FIG. 24C) is read. In the character string parent / child node list, the corresponding character variable Symbol (“σ” in the example of FIG. 24) is arranged.

  Step 540) The character string parent / child node (FIG. 24C) and the character corresponding to the character string child node are aligned with the same variable (FIG. 24D). Since this process is a process of matching characters existing at corresponding positions between character string variables, it is possible to generate test data that satisfies the inclusion relationship between the character strings. This processing is performed for each character string parent-child node in the character string parent-child node list. Details will be described later with reference to FIG.

  Step 550) Assign a specific character value to the character variable. For example, there is a method of applying characters randomly selected from alphabets in the range of “a” to “z”. The value of the character variable assigned in this way is output to the test case storage unit 160.

  Next, the process of S540 in FIG. 23 will be described.

  FIG. 25 is a detailed flowchart of S540 in FIG. 23 according to the embodiment of the present invention.

  Step 1010) The character string determination unit 140 reads the character string parent-child node.

  Step 1020) The current position of the character string is set to 0.

  The following processing is performed on each character string child node of each character string comparison operator-specific child node group of the character string parent / child node.

  Step 1030) For each child node group of each character string comparison operator of the read character string parent and child node, the type of the character string comparison operator of each character child node of the character string comparison operator node group is a forward match. Alternatively, it is determined whether it is partial match, equality, or backward match. If it is a forward match or partial match, the process proceeds to step 1040. If it is equivalent, the process proceeds to step 1050. If it is a backward match, the process proceeds to step 1060.

Step 1040) A character string type variable pair list for forward matching and partial matching is generated. For details, set the character string of the string parent node to ps, the character string of the character child node to cs,
[(ps [character string current position], cs [0]), ..., (ps [character string current position + 1], cs [Length (cs) -1])
Create a string variable pair list. Then, Length (cs) is added to the current character string position, and the process proceeds to Step 1070.

Step 1050) Create a character variable pair list for equivalence. Specifically, the string parent node and the string child node are acquired, the string of the string parent node is ps, the m time string of the string child node is cs,
[ps [0], cs [0],…, (ps [Length (ps) −1], cs [Length (cs) −1])
Create a string variable pair list. Then, Length (cs) is added to the current character string position, and the process proceeds to step 1070.

Step 1060) A pair list of character string type variables for backward matching is created. Specifically, the character string parent node and the character child node are obtained, the character string of the character string parent node is set to ps, the character string of the character string child node is set to cs,
[(ps) [Length (ps) −Length (cs)], cs [0]],…, (ps [Length (ps) −1], cs [Length (cs) −1])
The character string variable pair list is created, and the process proceeds to step 1070.

  Step 1070) Align the characters of each character type deformation pair in the character type variable pair list generated in Steps 1040, 1050 and 1060 described above. Specifically, the character string comparison operator and the character type variable pair list generated in step 1060 are acquired, and the characters of the character string type modified pair are aligned based on the character string comparison operator. This process is performed for each character variable pair in the character variable pair list. Details are shown below.

  FIG. 26 is a detailed flowchart of S1070 in FIG. 25 according to the embodiment of the present invention.

  Step 1110) The character type deformation pair generated in Steps 1040, 1050 and 1060 is read.

  Step 1120) It is determined whether the set of the read character type variable pairs is a character type variable, a character type variable and a constant character (or a character type variable with a fixed value), or a constant character.

  If it is a character type variable, the process proceeds to step 1130. If it is a character type variable and a constant character, the process proceeds to step 1140. If it is a constant character, the process proceeds to step 1150.

  Step 1130) When the set of character type variable pairs is character type variables, the symbols assigned to the symbols of the two character type variables constituting the character variable type pair are set as X and Y, respectively. Outputs character variable pairs in which Symbol is replaced with X for all character variables used in the test case whose Symbol is X, Y.

  Step 1140) If the set of character variable pairs is a character variable and a constant character, a character variable pair in which the value of the character variable is replaced with a constant character is output.

  Step 1150) If the set of character variable pairs is constant characters, it is confirmed that the constants are equivalent. If the constants are not equivalent, a test data generation impossible error is output.

  Of the constraints included in the condition (1), condition (2), and condition (3) shown in FIG. 5 of the character determination unit 140, the character string variables correspond to each other based on the inclusion relationship between the character string variables. By determining the characters so that the characters existing at the positions match each other, the characters existing at the corresponding positions between the character string variables will match, so test data that satisfies the inclusion relationship between the character strings Can be generated.

  In addition, it is possible to construct the operation of each component of the test data generation apparatus as a program, install it on a computer used as the test data generation apparatus, execute it, or distribute it via a network.

  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.

DESCRIPTION OF SYMBOLS 10 User terminal 100 Test data generation apparatus 110 Test case extraction part 120 DB record number determination part 130 Integer / character string length determination part 140 Character determination part 150 Test data output part

Claims (10)

A test data generation device that generates test data for performing a functionality test that involves a read operation of data stored in a database (DB),
Test case storage means for storing test cases;
As design information, an input value definition that represents a domain of software input values, a process flow diagram that represents the flow of software processing, a DB definition that is database design information is acquired, input variables, DB table variables, and the software A test case extracting means for extracting a constraint that is a condition to be satisfied by the test data so as to cause a specific behavior of the test case, and storing it in the test case storage means;
Solving the restriction on the number of records of the DB table variable acquired from the test case storage means, determining the number of records of the DB table variable, generating DB record variables for the number of records, and storing the test case storage means Means for determining the number of DB records to be stored;
Deriving constraints on the string length from the constraints on the inclusion relationship between the string type variables obtained from the test case storage means, solving the constraints on the string length of the string type variable and the integer type variable, and the string length Integer / character string length determining means for storing variables and integer variables in the test case storage means;
A character determination unit that solves the restriction on the character string type variable acquired from the test case storage unit, determines a value of a character constituting the character string type variable, and stores the character value in the test case storage unit;
The input variable stored in the test case storage means, the output means for outputting the DB table variable as test data;
A test data generation apparatus comprising: The test case extraction means includes
Extract “constraints on input values” from the input value definition and the processing flow diagram, and extract “constraints on the number of search hits, input values, DB initial state dependency” from the DB search conditions of the processing flow diagram, The test data generation apparatus according to claim 1, further comprising means for extracting “a constraint on the DB initial state” from the DB definition. The record number determining means is:
When a complex DB table record group corresponding to a nested array is detected, the “DB table record group represented by the inequalities included in the“ restrictions regarding the number of search hits, input values, and DB initial state dependency ” Including the means to determine the number of DB records in the DB table variable by selecting `` Restriction on number of cases '' and solving as simultaneous inequalities,
The integer / character string length determining means includes:
When a record group of a complicated DB table corresponding to a nested array is detected, the “constraints on input values” extracted by the test case extraction unit, the “number of search hits, input values, DB initial state dependency” ”Restriction on DB” and “Restriction on DB initial state”, select “Constraint on length of character string” expressed by inequalities, and determine the length of the array by solving as simultaneous inequalities 3. The test data generation apparatus according to claim 2 , further comprising means. The record number determining means is:
4. A means for selecting a constraint relating to a primary key and a foreign key of a DB record from the “constraints for the DB initial state” and transforming the constraint into a constraint for comparing integer variables or comparing string variables. Test data generator. The integer / character string length determining means includes:
Of the “constraints for the DB initial state”, select a constraint on the primary key and foreign key of the DB record, and convert the constraints into comparisons between integer variables, the “constraints on input values”, the “number of search hits, input values, Select `` integer constraints '' represented by inequalities included in either `` Constraints on DB initial state dependency '' or `` Constraints on DB initial state '', solve constraints on selected integers as simultaneous inequalities, 4. The test data generation apparatus according to claim 3, further comprising means for obtaining a value satisfying the constraint group. The character determining means is
Correspondence between the character string variables based on the inclusion relationship between the character string variables included in any one of the “restrictions on input values” and “restrictions on the number of search hits, input values, and DB initial state dependency” test data generation apparatus according to claim 2 Symbol mounting includes means for determining the character and the value of the character to a character present at a position coincide respectively. A test data generation method for generating test data for performing a functionality test accompanied by a read operation of data stored in a database (DB),
The test case extraction means obtains the input value definition that represents the domain of the software input value, the process flow diagram that represents the software process flow, and the DB definition that is the database design information as the design information, and the input variables and DB A test case extraction step of extracting a table variable and a constraint that is a condition that the test data should satisfy so as to cause a specific behavior of the software, and storing it in a test case storage unit;
DB record count determination unit has acquired from the test case storing means, solves the constraint on the number of records of the DB table variable, DB number of records to determine the number of records of the DB table variable, is stored in the test case storage unit A decision step;
The integer / character string length determining means derives the restriction on the character string length from the restriction on the inclusion relation between the character string type variables obtained from the test case storage means, and the character string length and the integer type of the character string type variable are derived. Integer / character string length determination step for solving constraints on variables and storing character string length variables and integer type variables in the test case storage means;
A character determining unit that resolves restrictions on the character string type variable, determines a value of a character that constitutes the character string type variable, and stores the character value in the test case storage unit;
An output means for outputting the input variables stored in the test case storage means and the DB table variables as test data; and
The test data generation method characterized by performing. In the test case extraction step,
Extract “constraints on input values” from the input value definition and the processing flow diagram, and extract “constraints on the number of search hits, input values, DB initial state dependency” from the DB search conditions of the processing flow diagram, Extract “Restrictions on DB initial state” from the DB definition,
In the record number determination step,
When a complex DB table record group corresponding to a nested array is detected, the “DB table record group represented by the inequalities included in the“ restrictions regarding the number of search hits, input values, and DB initial state dependency ” Select `` Restriction on number of records '' and solve the simultaneous inequality to determine the number of DB records for the DB table variable.
In the integer / string length determination step,
When a record group of a complicated DB table corresponding to a nested array is detected, the “constraints on input values” extracted by the test case extraction unit, the “number of search hits, input values, DB initial state dependency” Select the "constraint length related to string length" represented by the inequalities included in either of the "constraints on" and "constraints on the DB initial state", and determine the length of the array by solving as simultaneous inequalities Item 8. The test data generation method according to Item 7. In the record number determination step,
Select the constraint on the primary key and foreign key of the DB record from the above `` Constraint on DB initial state '', and transform it into a constraint that makes comparison between integer variables or comparison between string variables,
In the integer / string length determination step,
Of the “constraints for the DB initial state”, select a constraint on the primary key and foreign key of the DB record, and convert the constraints into comparisons between integer variables, the “constraints on input values”, the “number of search hits, input values, Select `` integer constraints '' represented by inequalities included in either `` Constraints on DB initial state dependency '' or `` Constraints on DB initial state '', solve constraints on selected integers as simultaneous inequalities, The test data generation method according to claim 8, wherein a value satisfying the constraint group is obtained. In the character determination step,
Correspondence between the character string variables based on the inclusion relationship between the character string variables included in any one of the “restrictions on input values” and “restrictions on the number of search hits, input values, and DB initial state dependency” test data generation method according to claim 8 Symbol mounting includes means characters to determine the value of the character matching characters each present at a position.

Images