JP2001222429A - Test item generation supporting device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To support simple work and a work with many reference items and to generate only practically sufficient test items for a set type being one of the factors of the increase of test items in a test items generation supporting device for supporting a test work based on object directional design. SOLUTION: This device is provided with an equivalence class holding part for inputting and holding the equivalence class for every object, an input parameter equivalence class generating part for reading an object directional CASE tool based on UML semantics and the information of the equivalence class from the equivalence class holding part, and for reading the signature of one method, and for generating the equivalence class of the input parameter of a method to be tested, and a test item generating part for generating a test item from the equivalence class. Then, all the equivalence classes of the input parameters of methods to be tested including inheritance relations are described, and test items are generated based thereon.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to an object-oriented test item generation support apparatus for supporting a test operation based on an object-oriented design.

[0002] As software is used in various fields and its scale increases, the effects of its bugs are becoming more serious. Therefore, it is required to reduce the number of test creation steps as much as possible, to remove bugs in advance, and to perform necessary tests without fail.

[0003]

2. Description of the Related Art Conventionally, a functional test of application software has been designed by a tester based on functional specifications. Since test design is performed later in the development, man-hours cannot be devoted to the entire test work. In addition, since test design requires understanding and experience of the target application, experienced developers had to work on test design.

[0004] For this reason, if a person who has little experience designs a test, a situation may arise in which the conditions under which the operation of the application changes are overlooked, and variations in the combination of conditions are not sufficiently created.

[0005] In recent years, since the emergence of the object-oriented language, object-oriented design has become necessary for object-oriented programming, and object-oriented analysis has become necessary for object-oriented design. Various methodologies for applying such object orientation to various industries and businesses have been proposed but are not standardized, and the notation of the model is described in UML (Unified Mode).
ling Language) as OMG (Object Management Grou
p).

[0006] In object orientation, an object holds data (state, information, data structure) and some operations for processing the data. An object obtained by abstracting objects having the same properties is called a class, and the class includes a name, an attribute, and an operation. There are two levels of object abstraction: data abstraction and super abstraction. Data abstraction is an abstraction when a class is created from an object. It is omitted as an accidental property, and properties (attributes) that are not fundamental to the system are also omitted. On the other hand, super abstraction refers to further abstracting classes having the same property (the same fundamental property for the target system) among a plurality of classes. A super-abstracted class is called a superclass, and the class on which it is based is called a subclass. A superclass defines common properties of multiple classes,
Subclasses are defined leaving only the unique properties that could not be standardized.

[0007] In testing such object-oriented application software, not only the method to be tested, but also related objects and superclasses have to be considered, which is further complicated.

[0008] As one of the test techniques, there is an equivalent division technique. In this method, for example, an application uses "i" representing int (integer) and "s" representing String (character string) as arguments, and i of int is i
In some cases, the application performs different calculations according to each condition of <0, 0 ≦ i ≦ 100, 100> i. Such division of i is referred to as equal division in three cases. When testing the operation of an application that is divided into equivalences in this way, if one of the representative examples in each of the three cases is selected and tested, it is confirmed that any of the values operates correctly. . In this example, there are not only i but also s as arguments, and s
If the operation of the application changes also for
Types (three types in this example) and s
Test items are created by processing of combinations of values (in this example, two types) that can be taken as (3 × 2 = 6 pairs in this example). However, since the actual application uses a large number of arguments, simply combining them results in a huge number of test items, and in fact, it takes time to create and execute test cases for all of them. In addition, the work was enormous and extremely difficult.

[0009]

SUMMARY OF THE INVENTION Test design work includes:
There are tasks that can be performed only from the object design information. That is, conventional UML semantics (Semant
ics) -compliant (conforms to the definition and meaning of each notation specified by UML) CASE (Computer Aided Software
(Engineering) tools can help you with your design work by seeing what arguments are there, but the test items created by that work are the minimum requirements for testing your application, but are simpler. In addition, since there are many reference items, there is a problem that oversight is likely to occur and the burden on the operator is increased, and a work error is likely to occur.

In addition to the function test, there is a method of executing all the source codes at least once, but there is a problem that it takes time and effort.

The present invention uses a design document created at the time of development to support simple work and work with a large number of reference items, and a set type (array, list, etc.) which is one of the causes of an increase in test items. It is an object of the present invention to provide a test item generation support device that can suppress test items to an executable level by generating only test items that are practically sufficient for a type including a plurality of elements). .

[0012]

FIG. 1 shows the principle of the present invention. In the figure, reference numeral 1 denotes an equivalence class holding unit that holds an equivalence class required for a test, 2 denotes an input parameter equivalence class generation unit that generates an input parameter of the equivalence class to a method to be tested, and 3 denotes an input parameter equivalence class generation. An equivalence class format file in which the equivalence class data generated by the section 2 and the internal state equivalence class generation section 6 are stored and output, and 4 is a test item generation for generating test items by combining the listed equivalence classes. And 5, a test item format file in which the test item format generated by the test item generating unit 4 is stored. Reference numeral 6 denotes an object or master required in the method (program) to be tested based on the information from the equivalence class holding unit 1 and an internal state equivalence class generation unit that enumerates the equivalence classes, 7 denotes a control unit, 8 Is a UML semantics-compliant OO-CASE (Object Oriente) that guarantees that the class name, argument name, etc. of the target method can be taken.
d-Computer Aided Software Enviroment (object-oriented software support environment) tool, 9 presents display output to users, edits display contents by users,
An input / output unit for inputting an instruction.

FIG. 2 shows an example of the structure of data stored in the equivalence class storage unit. An equivalence class indicates a range of values in which an application operates in the same process, and an equivalence class is provided for each object or type. When assigning an equivalency class, attach a “positive” tag if the value of the equivalency class causes normal processing of the application and a “different” tag if it causes an error. Do not tag. These tags are used when devising to reduce test items in later work. FIG.
, 10-n represent class name 1, class name 2,..., Class name N, respectively. In the case of class name 1 (10-1), the equivalent class 1-1 is The range “positive” and the equivalence class 1-2 are class names corresponding to the range “different” (error), and the class name s of 10-m
In the case of tr (representing a character string), "null (no content)" indicates "different" (error), and if the length is 0, "correct"; Correct. "

An equivalent class is created by a test designer by using a class name as a key from an equivalent class holding table (not shown). Although there are differences from application to application, the equivalence classes of the basic types can be used in all applications. Test items are created using these equivalence classes. Therefore, by generating sufficient equivalence classes here, subsequent work can be reduced.

The operation of FIG. 1 will be described. With the equivalence class storage unit 1 storing the equivalence class data as shown in FIG. 2 in the form of a table, the operation of the input parameter equivalence class generation unit 2 conforms to UML semantics. CA
Based on the information obtained from the class diagram of the SE tool 8, the data of the equivalence class that enumerates the equivalence classes of the input parameters for the operation of the test target method is extracted and stored in the equivalence class format file 3. The contents of the format file 3 of the equivalence class are displayed and output to the input / output unit 9, and the user can edit (select, delete, etc.) the output equivalence class from the input / output unit 9. Next, the test item generation unit 4 generates test items by combining the equivalence classes from the documents written in the equivalence class format listed in the equivalence class format file 3 and outputs the test items to the test item format file 5. .

On the other hand, when the internal state equivalence class generation unit 6 is driven, the method to be tested based on the information from the equivalence class holding unit 1 and the information obtained from the class diagram and sequence diagram in the CASE tool conforming to the UML semantics is used. Objects and masters required in the (program) and their equivalent classes are listed and stored in the equivalent class form file 3. The data of the internal state equivalence class stored in the equivalence class form file 3 is combined with the equivalence class of the internal state and the equivalence class of the input parameter by the test item generation unit 4 to generate a test item. Stored in file 5. The contents of the test item format file 5 are displayed and output from the input / output unit 9 and presented to the user (designer), and can be edited by the user.

The control unit 7 specifies a public method (Pu
blic method: A super class of the specified class (including both inheritance of implementation and inheritance of interface) as well as UML semantics-compliant OO-CA, as well as a method that can be accessed from other classes.
It detects from the class diagram in the SE tool 8 and generates a test item of the public method of the class.

[0018]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The main parts shown in the principle configuration of the present invention shown in FIG. 1 are provided with a CPU, a processing part by a program including a memory, an input part such as a keyboard and a mouse, and a display part such as a display. A processing flow that can be realized by the program processing by the information processing device and realizes the function of each unit will be described below.

FIG. 3 is a processing flow of the input parameter equivalence class generation unit (2 in FIG. 1). In this processing, an equivalent class of an input parameter of a designated method and an object related thereto is created based on information acquired from an equivalent class holding unit and a UML semantics-compliant OO-CASE tool, which will be described below. .

As a signature of a specified method (M of a program) for which a test is to be generated, arguments of the method and its types, return types, classes associated with the class having the method, and the associated Type, reference direction,
It has multiplicity and super class. These are OO-
The number N (total number) of the arguments is acquired from the signature of the method M, acquired from the CASE tool (S1 in FIG. 3). Next, i representing the argument number is set to 1 (S2), and it is determined whether i is N or less (S3). In the following cases, the i-th argument of the method M (A and A in this example) is used. Is obtained (S5), an equivalence class information object (E in this example) is created (S6), and the formal parameter name of E is set to the same as the formal parameter name of A described above. (S7).
Next, an equivalent class creation process is performed (S8 in FIG. 3). The content of this equivalence class creation processing will be described later with reference to FIGS.

Thereafter, it is determined whether the type of the acquired A is an object (S9), and if it is not an object, the process proceeds to S11 described later, and if it is an object, an equivalent class acquisition process for the object is performed (S10). ).
The details of the equivalence class acquisition processing for this object will be described later with reference to FIG. Subsequently, it is determined whether the type of A is a set (array). If the type is not a set, the process proceeds to S13, and if it is a set, an equivalent class acquisition process for the set is performed (S12). The details of the process of acquiring the equivalence class for this set will be described later with reference to FIG. Next, i is incremented by 1 (S13 in FIG. 3), the process returns to S3, and the same process is performed. When i exceeds N, the output process of the input parameter equivalent class is performed (S4).

FIG. 4 is a flowchart of the equivalence class creation process (the process executed in S8 of FIG. 3 and using the type name of A and the equivalence class table). First, the type name of E (the type name of the equivalence class) is set to the type name of A (obtained in S6 of FIG. 3) (FIG. 4).
S1). Next, super class acquisition processing (type name of A) is performed (S2 in FIG. 4). The details of this superclass acquisition processing (type name A) are shown in FIG. 5, and this processing is processing for making the equivalent class of the object serving as the base point available, and the superclass will be described here. ,
The superclass S of A is acquired from the OO-CASE tool (8 in FIG. 1) (S20 in FIG. 5), and the process ends if there is no S (superclass). ), The equivalent class of the class S is acquired and added to the equivalent class of E (S22 in FIG. 5), and the super class acquisition processing (S) is executed (S23). Details of the super class acquisition processing (S) are shown in FIG.

Returning to FIG. 4, following the superclass acquisition processing, an equivalence class is acquired from the equivalence class holding unit (1 in FIG. 1) using the type name of the argument A as a key (S3 in FIG. 4). An equivalence class is acquired from the class holding unit using the type name of A as a key, and all the equivalence classes are added to the equivalence class of E (S4). Subsequently, E is added to the equivalence class table (S5 in FIG. 4), and the equivalence class creation processing ends.

FIG. 8 shows the structure of the equivalence class table.
The equivalence class table created by the processing of FIG. 4 stores the equivalence class information individually as shown in FIG.
Information is stored in the order of the formal parameter name, the field name, the type name, and the equivalence class.

FIG. 6 is a flowchart of the equivalence class acquisition process for the object (the process of S10 in FIG. 3). First, the number M of attributes of class A is acquired from the OO-CASE tool (S1 in FIG. 6), j indicating the number of attributes is set to 1 (S2), and it is determined whether j is M or less (S1). S3) If the value is not M or less, the process ends. If the value is M or less, the j-th attribute is acquired (S4), and an equivalence class information object E1 is created (S5). Subsequently, the j-th attribute name of A is set as the field name of E1, the type name of the j-th attribute of A is set as the type name (S6 in FIG. 6), and then the equivalence of the equivalence class information object E1 is set. Class creation processing (A type name) is performed (S7, see FIG. 4), j is incremented by 1 (S8),
The process returns to S3.

FIG. 7 is a flow chart of the equivalent class acquisition process (the process of S12 in FIG. 3) for the set (array). First, the type T of an element of the class A is acquired from the OO-CASE tool (S1 in FIG. 7), an equivalent class information object E1 is created (S2), and the element of A is indicated as a field name of E1. A name A [i] is set, a type name is set to T (S3), and E1 is an equivalence class table (see FIG. 8).
(S4).

In contrast to the processing flow of the input parameter equivalence class generation unit shown in FIG. 3, the processing flow in the case where the input parameter is a method and it has an aggregation relationship with another object is described in the first application example of the equivalence class generation unit. FIG. 9 shows a processing flow.

In FIG. 9, first, the number N of classes having an aggregation relationship with the class of the argument A is obtained from the OO-CASE tool (S1 in FIG. 9), and the value of i is set to 1 (S2 in FIG. 9).
It is determined whether i is equal to or less than N (S3). If the value is not equal to or less than N, the process is terminated. The related name R is obtained (S4). Using this, an equivalence class information object E1 is created (S5), and E1
Is R, the type name of E1 is C (S6),
Equivalent class creation processing (E1, C) is performed (S7). This equivalence class creation processing is as shown in FIG. Next, E1 is added to the equivalence class table (S8), and the subsequent processing of S9 to S13 is performed in S9 of FIG.
To S13, and a description thereof will be omitted. According to the processing of FIG. 9, in addition to the input parameters, other objects in an aggregated relationship can generate more sufficient test items, and the burden on the test designer can be reduced.

Next, FIG. 10 shows an application example 2 of the equivalence class generation unit.
It is a processing flow of. In this processing flow, in the processing of the input parameter equivalence class generation unit shown in FIG. 3, the direction of another object related to tracing the aggregation relationship (if one object can refer to or see another If there is a direction to the object), the direction is defined as navigation, and the processing of application example 2 in FIG.
Only the related object indicated by is added to the input parameter.

First, an argument A is sent from the OO-CASE tool.
The number N of classes in an aggregate relationship with the class of
S1), the value of i is set to 1 (S2), and it is determined whether i is N or less (S3). If i is not less than N, the process ends. If N is less than N, the argument A from the OO-CASE tool is used. Then, the name C, the related name R, and the related direction (indicated by Navi) of the class that is in an aggregate relationship with the class are acquired (S4). Then Na
It is determined whether or not vi is set to be able to refer to the related class C from the class that is the type of the argument A (S5). If not set, the process proceeds to S14 to perform processing of incrementing i by +1. If the field name of E1 is R, E
1 is set to C (S6), and the equivalent class creation processing (E
1, C) (S7). This equivalence class creation processing is as shown in FIG. Next, E1 is added to the equivalence class table (S8), and the following S9 to S1
The processing of No. 3 is the same as S9 to S13 of FIG. By the processing of FIG. 10, unnecessary tests are not generated, so that the burden on the test designer can be reduced.

FIG. 11 is a flowchart of the output process of the equivalent class.

This processing is executed for the format file 3 of the equivalence class shown in FIG. 1 and output and displayed on the display. First, output the document name (Fig. 1
1, S1), the name of the target method for generating the test item is output (S2), and a blank line is output (S3). Subsequently, the table name and the column names of the table are output (S4 in FIG. 11), the length N of the table is obtained (S5), an equivalent class output row is set (S6), and the variable i is set. Is set to 1 (the same S
7) It is determined whether i is N or less (S8). If not, a symbol indicating the end of the table is output and the process is terminated (S9). If i is N or less, the i-th class in the equivalence class table is performed. Is set as E (S10), and the formal argument name, field name, and type name of E are output (S11). Next, the number M of equivalence classes is obtained (S12 in FIG. 11), the variable j is set to 1 (S13), and it is determined whether j is M or less (S1).
4) In the following cases, the j-th equivalence class C of the i-th equivalence class is acquired (S15).
Subsequently, the correct / different of C and the name of C are output (S16, S1).
7), a line feed is performed (S18), and j is incremented by 1 (S1).
9) Return to S14 and repeat the same process. S14
If j is not equal to or less than M, i is incremented by 1 (S20 in FIG. 11), the process returns to S8, and the following processing is repeated.

FIG. 12 shows an example of the output format of the equivalence class, and FIG. 13 shows a class diagram of the equivalence class and an equivalence class table.

The output format of FIG. 12 is output according to the output processing flow of FIG. This is an example of the input parameter equivalence class table, and when outputting the equivalence class of the internal state, it becomes the “internal state equivalence class table”. The input parameter equivalence class table shown in FIG. Object of the class "udef" having the structure of
It shows an equivalent class of method class A: method A (udef obj, String strl) having an ing (character string) type object as an argument. That is, in the example of the input parameter equivalence class table, the class name is A, the method name is A, and
The type name of the first object is “udef”, its argument name is “obj”, and the type name of the next object is “St”.
ring ", and its argument name is" str1 ". When FIG. 12 is used to output the equivalence class in the internal state, the first column name is the object name.

FIG. The class diagram having the relationship shown in FIG. Is created. FIG. Defines a class "udef" as a subclass of the class "object"
It indicates that the attribute of the class of "ef" is "int" (integer) and the field name is "attr1". Further, the class “udef” indicates that the class “int”, which can take a value of 0 to N, has an aggregation relationship. Using such a class diagram, B. of FIG. Is stored in the input parameter equivalence class generation unit (2 in FIG. 1).

FIG. 12 shows columns of a formal argument name, a field name, and a type name from the first column. The contents corresponding to the table shown in are set.
Equivalent classes of “positive” and “different” are set respectively.

FIG. 14 is a processing flow of the test item generation unit. This processing is executed by the test item generation unit 4 of FIG. First the table list (represented by TL)
To read the equivalence class into
1). This process is performed on the equivalence classes generated in FIGS. 3 to 10 described above.
5, shown in FIG. Following the reading process, the document name is output (S2 in FIG. 14), and an equivalent class table (represented by T) at the head of the table list is obtained (S3). Next, the key K of the table T is output as the target method name (S4 in FIG. 14), and a blank line is output (S4).
5) The name of the table is output, and using the equivalence class information object in the table T, the formal argument name, the field name, and the type name of the equivalence class information object are output as column names of the table (S6).

Subsequently, a combination process is performed for the equivalence class using the table list TL as an argument (S7 in FIG. 14). This combination process is shown in FIG. 17 described later. When the combination process is performed, the total number of tables (represented by TTotal) in the table list (TL) is obtained (S8).
i = 2 is set (S9), it is determined whether i is less than or equal to the total number (TTotal) (S10), and if it exceeds the total number, the processing is terminated. If it is less than the total number, the table list (TL) contains Set the i-th equivalence class table (S1
1). Next, the key K of the table (T) is output as the target data name (S12), and a blank line is output (S1).
3) Output the name of the table, use the equivalence class information object in T, and output the formal argument name, field, and type name of the equivalence class information object as column names of the table (S1).
4). Next, a combination process is executed using the TL as an argument for the equivalence class information output in S14 (S1).
5), i = i + 1 is executed (S16), and the process returns to S10. The details of the combination process (TL) are shown in FIG.

FIGS. 15 and 16 show the flow (part 1) and (part 2) of the equivalence class reading process. This process is a process for reconstructing the equivalence class table from the format of the equivalence class. However, in this process, the type representing the set is used as an identifier, and it is used as another equivalence class table. When outputting, the set creates another table.

First, an empty table list TL is created, the counter j of the equivalence class table is initialized to 1 (S1 in FIG. 15), and an empty class table CTj is newly created (S2). The number of top lines described in the equivalent class is set in the line number counter i, and the method name of the equivalent class is set in Tag (tag) (S3 in FIG. 15). It is determined whether i is the last row of the table (S4 in FIG. 15), and if it is not the last row, it is determined whether both the temporary row number name column and the field name column of the i-th row are empty (S5). If it is empty, 1 is added to i (S6 in FIG. 15), and the process returns to S4. If it is not empty, an equivalence class information object E is created (S in FIG. 15).
7) Read the formal argument name, field name, and type name for the object, and set them in the equivalence class information object E (S8).

It is determined whether or not the type of E represents a set (S9 in FIG. 16). If the type does not represent a set, the value of the positive / different column in the i-th row and the value of the equivalence class column are paired. To the equivalent class of E (S10), and add 1 to i (S10).
11). Subsequently, it is determined whether both the formal parameter name column and the field name column on the i-th row are empty (S12 in FIG. 16). If both are empty, the process returns to S10, and if either is not empty, to create a new equivalence class, first add the currently used equivalence class information object E to CTj (FIG. 16).
Return to S13) and S4. If it is determined in S9 that the type name of E represents a set, CTj and a tag are paired and added to the table list TL (S14 in FIG. 16).
Subsequently, 1 is added to the counter j of the equivalence class table (S15), a new equivalence class table CTj is created (S16), and the E field name is set in the tag (S1).
7), the process of S6 is performed.

FIG. 17 is a flowchart of a combination process that takes the table list TL as an argument, which is executed in S7 of FIG. In this process, test items are created by combining equivalence classes, and the table lists created in FIGS. 15 and 16 are used. In this process, a combination flag (flag) is used. This is a flag used to generate only the minimum combination when combining equivalence classes in different equivalence class tables, and is initially set to 0 (S1 in FIG. 17). The first class table in the table list is obtained, and the equivalence classes of the equivalence class information included therein are combined (S2). At the time of combination, the number of abnormal equivalent classes in each combination is counted (S3 in FIG. 17). In order to process all combinations, first, the total number (To
tal) (S4 in FIG. 17), the counter k is initialized to 1 (S5), it is determined whether or not k is equal to or less than Total (S6). If k is equal to or smaller, the j-th combination is obtained (S7). ).

Subsequently, it is determined whether or not the flag (flag) is 0 (S8). If the flag is 0, the j-th combination is combined with the equivalent class of another (other than the head) class table in the table list TL. Test items (S
9). At this time, when an equivalence class acquired from a class table other than the head of the TL represents a certain range, a value near the boundary of the range (usually a value near the lower limit) is selected as a test item. In the process of S9, it is determined whether all the equivalent classes in the class table other than the head are used (S10 in FIG. 17), and if all the equivalent classes are used, 1 is set to the flag (flag) ( S11).

Thereafter, 1 is added to k (S1 in FIG. 17).
2) Return to the processing of S6. If all the equivalence classes are not used in the process of S10, the process of S12 is performed without changing the flag. If the flag (flag) is 1 in S8, the j-th combination is combined with a normal equivalent class in another (other than the first) class table in the table list TL to form a test item (S13 in FIG. 17). ). At this time, if an equivalence class acquired from a class table other than the head of the table list TL represents a certain range, a value near the boundary of the range (usually a value close to the lower limit) is selected as a test item, and thereafter, , S6. In step S6, when k becomes larger than Total, the combination process is terminated and a process S14 for output is executed.

FIG. 18 shows a specific example of the generated test item, which is generated by the processing of the test item generating unit shown in FIG.

FIG. Is a test item table, and the target method name for generating test items is classA: methodA (objec
t obj. string str1). This example is a test item of an input parameter, in which a combination of a dummy argument name, a type name, and an equivalence class is output. Specifically, "ob
jl "," obj.attllrl1 "," str1 "and" coll "
A. Various combinations are obtained as shown in FIG. Regarding the length, the length of the character string is set to the lower limit (length 0, length 2, etc.) or the maximum length. B. of FIG. Indicates a test item of an input parameter named “coll [i]” in which the target data is a set (array), and is a collection of integer arrays and B. if the length is 2 or more. Create test items by referring to the table shown in.

FIGS. 19 and 20 show the processing flows (part 1) and (part 2) of the equivalence class generation unit (6 in FIG. 1) in the internal state.
It is. In this processing flow, an equivalent class of an object to be referenced / updated in a specified program (method) and an object related thereto is stored in an equivalence class holding unit (1 in FIG. 1) and a OO-CAS conforming to UML semantics.
It is created based on information obtained from the E tool. In other words, it is a process for preparing what kind of data should be prepared as a database (holding data indicating the internal state) containing the data referred to by the program, and a necessary combination of states.

First, from the OO-CASE tool, a sequence diagram according to UML including a method M for generating a test (a diagram showing a state of processing) is searched to detect an object related to the operation of the method. (Figure 1
9 S1). Next, the number N of sequence diagrams including the method M
Is obtained (S2), i = 1 is set (S3),
It is determined whether i is equal to or less than N (S4). If i is equal to or less than N, the i-th sequence diagram S is obtained (S5), and the number L of objects appearing in the sequence diagram S is obtained (S6), j
(J is assumed to have been initialized to j = 1 by a process not shown) is determined to be L or less (S7). If L or less, the object o which appears j-th in the sequence diagram S is determined.
Is obtained (S8). Next, it is determined whether the object o is included in the signature (method name, argument type, return type, etc.) of the method M (S9 in FIG. 19). If not, the object o is included in the candidate list. In addition, the process proceeds from (S10) to S11, and if included, proceeds to S11, increments j by 1 (S11), and proceeds to S7. If j is not equal to or less than L in S7, i is incremented by 1 (S12 in FIG. 19), and the flow shifts to S4.

In S4, if i exceeds N (the number of sequence diagrams), the number K of objects in the candidate list
(S13 in FIG. 20), create an empty table CT (S14), set i to 1 (S15), determine whether i is within K (S16), and if The i-th object o in the candidate list is obtained (S18).
Next, from the equivalence class holding unit (1 in FIG. 1), the object o
An equivalence class is acquired using the type name of
9), create an equivalence class information object E (S
20). Next, the formal argument name of the equivalence class information object E is set to the class name of o (S21 in FIG. 20), and the equivalence class creation process (o. Class name) of the object E is performed (S22). This equivalence class creation process is described in FIG.
This is the same as that shown in FIG.

Subsequently, it is determined whether the type of o is an object (S23 in FIG. 20), and if it is an object, an equivalent class acquisition process for the object (see FIG. 6) is performed (S24).
Is performed, the equivalence class information object E is added to the equivalence class table CT (S25), and i is set to +
1 (S26), the process proceeds to S17, the internal state equivalent class output process is performed, and the process returns to S16. Also, S1
In step 6, even if i exceeds k (the number of objects in the candidate list), the processing of S17 is also performed.

By the processing of FIGS. 19 and 20, in the sequence diagram where the method to be tested appears, objects other than the input parameters and return objects of the method to be tested are candidates for the object related to the operation of the method. And These candidates include those required for other objects, and the equivalence class table generated in this process can be modified in the same way as the input parameters. Items can be created. More detailed test design can be performed by combining the test items in the internal state with the test items of the input parameters. The test items for the internal state are:
It is a guide to what records should be prepared in the database created for testing.

In each of the above-described processes, the method is specified as a test target, and the input parameters and the state of the database for the method are created. Want to do a test. The control can be realized by the control unit, which will be described below.

FIG. 21 is a processing flow of the control unit (7 in FIG. 1) by class designation. In this processing flow, the specified class and the public methods of its superclass (methods that can be called from outside and are distinguished from private methods used in internal operations) are OO
-Shows a process of taking out from the CASE tool and generating an equivalence class and a test item for each public method.

That is, first, a class C for generating a test item is inputted (S1 in FIG. 21), and the number N of public methods included in the class C is obtained from the OO-CASE tool (8 in FIG. 1) ( S2), method name list (M
L) (S3), and i is set to 1 (S3).
4), it is determined whether i is less than or equal to N (S5). If i exceeds N, the process proceeds to S11, and this process is performed on the superclass of class C ("Control unit by class designation shown in FIG. 21"). Process)). If i is equal to or less than N in S5, the i-th public method M included in the class C is acquired from the OO-CASE tool (S6). Next, for the method M, the process of the equivalence class generation unit of the input parameter is called, the format M1 of the equivalence class is acquired (S7 in FIG. 21), and for the method M, the processing of the equivalence class generation unit in the internal state is performed. And outputs the equivalent class format M2 (S8), adds the method name M to the method name list ML (S9), and increments i by 1 (S1).
0), and the process shifts to S5.

As described above, test items can be created for all public methods of the class specified by the class specification, and it is possible to support test design in consideration of the object-oriented property.

[0056]

According to the present invention, a design document is
If the OO-CASE tool based on the ML semantics complies with the OO-CASE tool, it is possible to support the test design using the information included therein. Creating information of the equivalence class holding unit according to the present invention is easier than creating test items directly. If sufficient equivalence classes are extracted here, the generated test items will be better. Become.

If the number of test items to be generated is large, only the executable number of test items are extracted and executed. This means that if you decide on a selection policy within the group, even those who are not familiar with the application can select necessary and sufficient test items.

[Brief description of the drawings]

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

FIG. 2 is a diagram illustrating a configuration example of data stored in an equivalence class storage unit.

FIG. 3 is a diagram showing a processing flow of an input parameter equivalence class generation unit.

FIG. 4 is a diagram showing a flow of an equivalence class creation process.

FIG. 5 is a diagram illustrating details of a superclass acquisition process (model name A).

FIG. 6 is a diagram showing a flow of an equivalent class acquisition process for an object.

FIG. 7 is a diagram showing a flow of an equivalent class acquisition process for a set (array).

FIG. 8 is a diagram showing the structure of an equivalence class table.

FIG. 9 is a diagram illustrating a processing flow of an application example 1 of the equivalence class generation unit.

FIG. 10 is a diagram illustrating a processing flow of an application example 2 of the equivalence class generation unit.

FIG. 11 is a diagram showing a flow of an equivalent class output process.

FIG. 12 is a diagram illustrating an example of an output mode of an equivalence class.

FIG. 13 is a diagram showing a class diagram of an equivalence class and an equivalence class table.

FIG. 14 is a diagram illustrating a processing flow of a test item generation unit.

FIG. 15 is a flowchart (part 1) of an equivalence class reading process.
FIG.

FIG. 16 is a flowchart (part 2) of an equivalence class reading process.
FIG.

FIG. 17 is a diagram showing a flow of a combination process.

FIG. 18 is a diagram illustrating a specific example of a generated test item.

FIG. 19 is a diagram illustrating a processing flow (No. 1) of the equivalence class generation unit in the internal state.

FIG. 20 is a diagram depicting a processing flow (No. 2) of the equivalence class generation unit in the internal state;

FIG. 21 is a diagram showing a processing flow of a control unit by class designation.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Equivalence class holding part 2 Input parameter equivalence class generation part 3 Equivalence class form file 4 Test item generation part 5 Test item form file 6 Internal state equivalence class generation part 7 Control part 8 OO-CASE based on UML semantics
Tool 9 input / output unit

Claims (4)

[Claims] A test item generation support apparatus for supporting a test operation based on an object-oriented design, comprising: an equivalence class holding unit for inputting and holding an equivalence class for each object; an object-oriented CASE tool conforming to UML semantics; An input parameter equivalence class generation unit that reads equivalence class information from the equivalence class holding unit, reads a signature of one method, and generates an equivalence class of an input parameter of the method to be tested, and The test item generation unit for generating a test item and the input parameter equivalence class generation unit describe all the equivalence classes of the input parameters of the method to be tested including the inheritance relation in a form that can be output in a predetermined format, and the test item The generation unit generates the input parameters described in the above format. A test item generation support device for generating a test item based on a data equivalence class. 2. The method according to claim 1, wherein the input parameter equivalence class generation unit adds the object to the input parameter when the input parameter of the method is an object, and when the method has an aggregate relationship with another object,
A test item generation support device, wherein the test item generation unit generates a test item. 3. The object according to claim 2, wherein the input parameter equivalence class generation unit refers to a navigation defined to indicate a direction of a related method when tracing an aggregation relationship, and a related destination object having a referenceable direction. A test item generation support device characterized in that only a test item is added to an input parameter. 4. A method according to claim 1, wherein a sequence diagram including a method to be tested is searched from an object-oriented CASE tool conforming to UML semantics, and an input parameter and a related object other than an input parameter and an object appearing in the searched sequence diagram are searched. And an internal state equivalence class generation unit for generating an equivalence class of the object is provided as a candidate for an object required when the method operates, and the equivalence class output from the internal state equivalence class generation unit is The test items are output in the same format as the equivalent class of the input parameters, the test item generator outputs the test items from the equivalent class of the format, and combines the test items of the input parameters and the test items of the internal state. Test item generation support device.