JP5901465B2 - Procedure manual generation apparatus, procedure manual generation method and program - Google Patents

Description

  The present invention relates to a procedure manual generation apparatus, a procedure manual generation method, and a program.

  A technique for supporting generation of a test procedure document used for testing a computer program or the like is known. For example, Patent Document 1 discloses a test specification creation device that creates a test specification (procedure manual) using information input at the design stage. In the technique described in Patent Document 1, when generating a test specification of a system, a user creates a setting file (test configuration INI file) that matches the test specification / system specification, and is input with this setting file at the design stage. Generate test specifications based on system information.

JP-A-11-282666

  In order to create a test specification (procedure manual) using the test specification creation apparatus disclosed in Patent Document 1, a setting file must be generated from scratch for each system and each test specification. For this reason, it takes much time and cost to create a setting file used to generate a test procedure manual, and there is a problem that efficiency is poor.

  The present invention has been made to solve the above-described problems, and an object thereof is to provide a procedure manual generation apparatus, a procedure manual generation method, and a program that can efficiently generate a test procedure manual.

  In order to achieve the above object, the procedure manual generation apparatus of the present invention is information indicating a process for generating generated data from original data, and an original data type that is an abstract type of the original data to be processed. A method for generating the generated data from the original data, a list storage unit for storing a processing list that is a list of processing information associated with a generated data type that is an abstract form of the generated data, and information on a test procedure. Including, an acquisition unit that acquires input data of an input type that is a data type included in the original data type, and a process stored in a process list stored in the list storage unit, the generation generated as a result of the process A generating unit that generates test procedure manuals from input data acquired by the acquiring unit, using the data as the original data for subsequent processing, and executed in the order determined by the processing list; and the generating unit An output unit for outputting the generated test procedures, characterized by having a.

  According to the present invention, a test procedure manual can be generated efficiently.

(A) is a figure which shows the physical structure of the procedure manual production | generation apparatus which concerns on Embodiment 1 of this invention, (b) is a figure which shows the functional structure of a procedure manual production | generation apparatus. It is a figure which shows the abstract design of the processing structure of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. It is a figure which shows the concrete design of the process structure of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. 6 is a diagram showing an example of a processing list according to Embodiment 1. FIG. (A) is an example of the data type of the state transition table stored in the type storage unit of the first embodiment, (b) is an example of the data structure of the state transition table, and (c) is the concrete data of the state transition table. It is a figure which shows an example. 5 is a flowchart showing edit setting processing according to the first embodiment. It is a figure which shows the typical setting example of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. 4 is a flowchart showing a procedure manual output process according to the first embodiment. (A) is a figure which shows the example of the concrete data input type which concerns on Embodiment 1, (b) is a figure which shows the example of a concrete data input part. (A) is an example of the internal data generation part which concerns on Embodiment 1, (b) is a figure which shows the example of the data structure of internal data, (c) is a figure which shows the example of internal data. 5 is a diagram illustrating an example of a selection unit according to Embodiment 1. FIG. (A) is a figure which shows the example of the data type of the selection table which concerns on Embodiment 1, (b) is an example of a selection table, (c) is a figure which shows the example of the production | generation data of a selection part. (A) is an example of the conversion part which concerns on Embodiment 1, (b) is a figure which shows the example of the data type of internal data, (c) is a figure which shows the example of a conversion table. (A) is a figure which shows the example of the procedure manual production | generation part which concerns on Embodiment 1, (b) is an example of the data type of a procedure manual, (c) is a figure which shows the example of procedure manual data. (A) is a figure which shows the example of a procedure manual output type | mold which concerns on Embodiment 1, (b) is a figure which shows the example of a procedure manual output part. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. (A) is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1, (b) is a figure which shows the example of the reference data which concerns on a setting example. (A) is a setting example of the procedure manual generation apparatus according to the first embodiment, (b) is an example of original data and generated data according to the setting example, and (c) is a diagram illustrating an example of reference data. (A) is a setting example of the procedure manual generation apparatus according to the first embodiment, (b) is an example of original data and generation data according to the setting example, (c) is a configuration example of the selection unit, (d) Is a diagram illustrating a configuration example of a selection unit, (e) is a diagram illustrating a configuration example of a conversion unit, and (f) is a diagram illustrating a configuration example of the conversion unit. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. (A) is a setting example of the procedure manual generation apparatus according to the first embodiment, (b) is an example of original data and generation data according to the setting example, and (c) is a diagram illustrating an example of reference data. (A) is a setting example of the procedure manual generation apparatus according to the first embodiment, (b) is an example of original data and generation data according to the setting example, and (c) is a diagram illustrating an example of reference data. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG. It is a figure which shows the example of a setting of the procedure manual production | generation apparatus which concerns on Embodiment 1. FIG.

  Hereinafter, a procedure manual generation apparatus according to an embodiment of the present invention will be described in detail with reference to the drawings. In the drawings, the same or equivalent parts are denoted by the same reference numerals.

(Embodiment 1)
As shown in FIG. 1A, the procedure manual generation apparatus 1 according to the present embodiment physically includes an information processing unit 11, a main storage unit 12, an external storage unit 13, an operation unit 14, a display unit 15, and An input / output unit 16 is provided.
The main storage unit 12, the external storage unit 13, the operation unit 14, the display unit 15, and the input / output unit 16 are all connected to the information processing unit 11 via the internal bus 17.

  The information processing unit 11 includes a CPU (Central Processing Unit) and a RAM (Random Access Memory).

  The main storage unit 12 includes a RAM (Random Access Memory) or the like. The main storage unit 12 loads control programs and processing information stored in the external storage unit 13 and is used as a work area for the information processing unit 11.

  The external storage unit 13 includes a nonvolatile memory such as a flash memory or a hard disk. The external storage unit 13 stores in advance a control program (program 18) for causing the information processing unit 11 to execute processing to be described later and processing information, and stores these control program and processing information in accordance with instructions from the information processing unit 11. The information is transmitted to the storage unit 12 or the information processing unit 11. Further, in accordance with an instruction from the information processing unit 11, a processing result of the information processing unit 11 and information transmitted from the input / output unit 16 are stored.

The operation unit 14 includes, for example, a keyboard, a mouse, and the like, and a transmission unit that transmits information on operations performed on these, and transmits information on user operations to the information processing unit 11.
The display unit 15 includes a liquid crystal display device, an organic EL (Electro Luminescence) display, and the like, and displays a screen based on a command from the information processing unit 11.

  The input / output unit 16 includes an input / output terminal, an I / O device (A / D converter, D / A converter, etc.), a communication device such as a modem, a LAN device, and the like. And connect.

As shown in FIG. 1B, the procedure manual generation apparatus 1 has a physical data input unit 110, an edit input unit 120, an editing unit 130, a storage unit 140, a process execution unit 150, a procedure manual output, as shown in FIG. Functions as the unit 160 and the display unit 170.
With such a functional configuration, the procedure manual generation device 1 uses information (processing list 210, abstract type 220, etc.) indicating processing procedures stored in the storage unit 140 from concrete input data including information indicating test procedures. Generate a test procedure.

  The test procedure describes a group of tests based on a specific test viewpoint for a specific system under test. Test viewpoints are associated with test factors (test parameters). For example, for the test viewpoint “drop test”, “drop height”, “number of drops”, and the like are factors. Each factor has a level. A level is the value of that factor in the test being performed. For example, when ON / OFF of the switch is a factor, “ON” and “OFF” are levels.

  The concrete data input unit 110 acquires information (concrete input data Din) indicating a test procedure from the external device or the external storage unit 13. The concrete data input unit 110 transmits the acquired concrete input data Din to the process execution unit 150.

The edit input unit 120 acquires operation information for editing information (processing list 210, abstract type 220, etc.) indicating the processing procedure executed by the user using the operation unit 14 or the like, or information for editing.
The editing input unit 120 transmits the acquired information to the editing unit 130.

  The editing unit 130 generates and edits the processing list 210, the abstract type 220, and the like based on the information transmitted from the editing input unit 120. The editing unit 130 displays a screen showing the contents of the current processing list 210 and the abstract type 220, a screen for editing work, and the like on the display unit 170 for editing operation.

  The storage unit 140 stores information transmitted from each unit of the procedure manual generation apparatus 1 and transmits the stored information to each unit. The storage unit 140 stores in advance (for example, at the time of factory shipment) information for setting processing / procedure manual output processing (described later) executed by the procedure manual generation device 1. The storage unit 140 includes a work memory 1410, a list storage unit 1420, and a type storage unit 1430.

  The work memory 1410 temporarily stores data used by the concrete data input unit 110, the process execution unit 150, the procedure manual output unit 160, and the like.

  The list storage unit 1420 stores one or a plurality of processing lists 210. The processing list 210 will be described later.

The type storage unit 1430 stores a plurality of abstract types (data types, processing types) used by each unit of the procedure manual generation apparatus 1 for processing. The data type is information indicating the structure of the data. When attached to actual data (concrete data), the data type is information indicating the structure of the data. The data type is an abstract type of data with a specific structure such as a table, tree, or recursive structure, as well as data with a single value (numeric data) and data indicating a character string (character string data). Is included.
The processing type defines information for realizing a certain unit of calculation processing. The processing type is information indicating information of the processing entity when the information processing unit 11 actually executes the processing on the concrete data.
Thus, when a concrete data / processing entity of that type is loaded, the abstract type (data type, processing type) becomes data describing the concrete data or processing entity data. At this time, the abstract type is also called metadata.
Here, for convenience, the data type and the processing type are described separately, but depending on the system that executes the following processing, the data type and the processing type can be treated as the same.

  The process execution unit 150 generates a test procedure document from the concrete input data Din transmitted from the concrete data input unit 110 using information stored in the storage unit 140. The process in which the process execution unit 150 generates the test procedure manual will be described later. The process execution unit 150 transmits the generated test procedure manual data (output data Dout) to the procedure manual output unit 160 and the display unit 170.

  The procedure manual output unit 160 outputs the test procedure manual data transmitted from the process execution unit 150 to an external device.

  The display unit 170 displays information transmitted from the processing execution unit 150 and the editing unit 130.

  By setting the process list 210 stored in the list storage unit 1420 by the setting process executed by the editing unit 130, the abstract structure of the process for generating the test procedure document as shown in FIG. 2 is determined. The setting process will be described later.

FIG. 2 is a model (abstract tool model) that abstracts the functions realized by the storage unit 140 and the processing execution unit 150 of FIG. In the example of FIG. 2, an abstract type (internal data generation type 220a) of a configurator that converts an abstract type of input data (input data type 220 _in ) is defined.
Then, internal data types 220 _{1 to} 220 _n are defined as abstract types of internal data used for processing. As a functional unit of processing using the internal data, a data selection function and a data editing function are defined as a selection type 220b and a conversion type 220c, respectively. Then, as a final step of the internal processing, the data of the internal data type 220 _n, as a function of generating output data, abstract configurator (instructions-generated 220d) are defined. Further, an output data type 220 _out is defined as the data type of the output data.

FIG. 3 shows the structure of a process that is generated based on the abstract type of FIG. 2 and is actually executed. In this process structure, a concrete input data Din that matches the data type 210 _in, the process entity matches the processing type 210a (internal data generation unit 150a) generates an internal data D1 matches the data type 210 _1. Then, the internal data processing entity in a selection unit 150b, like the process is an entity conversion unit 150c that matches the conversion type 220c is, that matches the internal type ₂₂₀ 2 to 220 _n that matches the selected type 220b (D2 to Dn) Are generated sequentially. Then, from the internal data that matches the internal data type 210n, the procedure manual generation unit 150d that is the processing entity that matches the processing type (procedure manual generation type 220d) generates the data of the procedure manual (matches the data type 210out). . The internal data types 220 _{1 to} 220 _n may all be the same data type.

  The abstract structure of processing as shown in FIG. 2 is defined by a processing list 210 shown in FIG. The processing list 210 is stored in the list storage unit 1420 of the storage unit 140, and the abstract type of each processing unit is registered in the execution order. The processing list 210 includes an identifier (“identifier”) of each row, a processing name (“processing name”) of the row, a data type (“original data type”) of the original data serving as a processing argument, and an acquisition source of the original data. ("Original data location") indicating information, an identifier ("operation") indicating data operation processing, a data type of generated data generated by processing ("generated data type"), and information indicating an output destination of generated data ( "Output location") is stored in association.

  Each processing entity receives the concrete data of the original data type from the original data location, and generates the generated data of the generated data type by operating according to the operation procedure (program function or the like) indicated by the “operation”. And it outputs to the site | part (memory address) which an output location shows. “Operation” includes an address of the storage unit 140 in which processing type information for generating a processing entity is stored.

In the process list, the output (generated data type and output location) of the previous process is set to match the input (original data type and original data location) of the next process. Note that the output of one process may have a plurality of generated data types and output locations. One process may have a plurality of original data types and original data locations.
At this time, the output of the immediately preceding process does not necessarily match the input of the next process on the process list, but when a certain process is executed, the original data required for the process is the original data location of the process Must be output.

  Here, the example in which the original data location and the output location are described in the processing list has been described. However, the present invention is not limited to this, and information indicating the original data location and the output location is included in the processing type, and the processing list may not include the information on the original data location and the output location.

  The data type and the processing type are stored in the type storage unit 1430 of the storage unit 140. An example of the data type will be described with reference to FIG. An example of the data type of the state transition table is shown in FIG. The data structure of FIG. 5A can be illustrated as shown in FIG. Further, an example of actual data of this data type is shown in FIG. 5A and 5B correspond to the “original data type” or “generated data type” in FIG. The start address of the actual data shown in FIG. 5C on the storage unit 140 corresponds to “original data location” or “output location” in FIG. Assume that certain internal data has a table structure as shown in FIG. The “state” and “event” in FIGS. 5A to 5C are factors (test parameters). In this example, a state and an event each have five data numbers means that a test for executing five events in each of the five states can be considered. For each factor (parameter), the actual value that is the object of test execution is called the level. The state transition table of FIG. 5C shows the correct test results (next state and system output) when events 1 to 5 are executed in each of the states a to e.

  The data structure of such a state transition table, the data type of FIG. 5A is the start point (“start position (x coordinate)” and “start position ( Y coordinate) ") and the number of data with respect to the coordinates (" data number (x coordinate) "and" data number (Y coordinate) "). Each row of the data type represents which part of one type of information (type of information such as “factor a” and “data”) indicates the data type.

  In the present embodiment, the data type is described in a domain-specific language (DSL) instead of a general-purpose modeling language such as UML. As the DSL, for example, the DSL used in the system design of the test target is used.

  Here, an example in which the information on the number of data is included in the data type of the table has been described, but the following processing is actually possible even if there is no number of data. For example, when the “event” in FIG. 5C is to be processed, if the process is executed while searching for the end point (for example, blank) in the y-axis direction from the start position (1, 1) that is the start point of “data”. Good. If the process is executed in the y-axis direction until reaching the end point (for example, blank), all “event” information can be sequentially processed even if there is no data.

  The processing contents and input interfaces defined by these processing types are specialized for the test target, but these processing contents and interfaces are the types of processing target data (number of types of factors, etc.), and each processing target It can be constructed so as not to depend on the attribute, range, and number of data. Specifically, by abstracting the process defined by each process type and making it a self-recursive process, the system does not depend on the order or the like.

  When constructing a concrete internal model, there are cases where the number of factors (number of sets of input data) does not simply change the number of iterations (loops), but the processing itself changes depending on the combination of factors. The fact that the processing content changes depending on the number of factors means that the program needs to be rewritten. On the other hand, by describing the repetitive type process as a self-recursive type process, even if the number of factors changes, it is possible to execute a process for generating the following procedure manual using the same process type.

Examples of processing that has been multidimensionalized by self-recursive processing include the following examples.
(1) A simple iterative (loop) process, such as N factorial calculation.
(2) The current state (N) depends on one or more previous (N-1), such as a difference number sequence and Fibonacci number sequence.
(3) The result (output) of one process, such as the Euclidean Mutual Assistance Method and the Tower of Hanoi, becomes the input of the next same process and continues until the end state is reached. At this time, the search process can be realized by a recursive process because a search of a certain range is performed, and if the search is successful, the same search is performed for the remaining range.
(4) The pipette table (aggregation table) is self-recursive because each hierarchy has the same structure (transitional relationship. For example, the first and second levels are the same structure) regardless of the order. The software structure can be made such that the basic process (self-recursive process) is repeated by the order of the factor.

  In the present embodiment, the process determined by the process type can be described as a self-recursive process as described above. As a result, the test procedure manual can be generated by a highly efficient and reusable method that does not depend on the order or the like.

The process execution unit 150 executes the processes registered in the process list in the order of the process list to generate a test procedure manual.
The process execution unit 150 includes a load unit 1510, an acquisition unit 1520, a generation unit 1530, and an output unit 1540. The load unit 1510 loads the process indicated by the line in the process list and generates a process entity. At this time, the acquisition unit 1520 accesses the original data location and acquires the original data of the process. The loaded processing entity becomes the generation unit 1530, and generates generation data (data to be processed next) from the original data. Then, the output unit 1540 outputs the generated data to the address on the work memory indicated by “output location”.
This address on the work memory becomes the original data location for later processing. In this way, the process execution unit 150 generates a test procedure document by executing the process registered in the process list like an interpreter.

  A process (edit setting process) that is executed by the editing unit 130 and sets / edits the processing list stored in the list storage unit 1420 will be described with reference to FIG. When the editing input unit 120 receives an operation for instructing to start editing the processing list, the editing unit 130 starts the editing setting process illustrated in FIG. In this editing setting process, the editing unit 130 in FIG. 1 edits information stored in the storage unit 140 (the processing list 210 in the list storage unit 1420 and / or the abstract type 220 in the type storage unit 1430). It is.

  In the editing setting process, the editing unit 130 first displays the processing list 210 stored in the list storage unit 1420 on the display unit 170. When the user performs an operation of selecting one of the displayed processing lists, the processing list is selected as the attention processing list (step S101). At this time, a new processing list may be created, and the created empty processing list may be used as the attention list.

  Next, the editing unit 130 determines whether or not to change the attention process list (step S102). Specifically, a screen for selecting whether or not to change the attention process list is displayed on the display unit 170. When the editing input unit 120 accepts an operation not changing, it is determined that the editing input unit 120 does not change (step S102; NO), and the editing setting process ends.

On the other hand, when the information to change is received (step S102; YES), it is determined whether or not the test target is a new system (step S103).
Specifically, a screen for selecting whether the test target is a new system or an existing system is displayed on the display unit 170. When the edit input unit 120 receives an operation indicating that the test target is an existing system (step S103; NO), the process proceeds to step S107.

  On the other hand, when an operation indicating that the system is a new system is received (step S103; YES), it is next determined whether or not a new abstract type is to be registered (step S104). Specifically, a screen for selecting whether or not to register a new abstract type is displayed on display unit 170. When the editing input unit 120 accepts an operation for registration (step S104; YES), the registration of a new abstract type is accepted (step S105).

  In step S105, a screen for inputting a new data type / processing type is displayed on display unit 170. When the user inputs a new data type / processing type using the editing input unit 120, the type storage unit 1430 stores the data type / processing type and makes it usable in the procedure manual generation apparatus 1.

  On the other hand, when an operation for not registering is accepted (step S104; NO), step S105 is skipped.

  Next, the editing unit 130 executes processing for editing an existing abstract type (step S106). Specifically, the existing abstract type is displayed on the display unit 170 in a selectable manner. Then, the edit input unit 120 accepts an operation in which the user selects and edits an existing abstract type. The editing unit 130 changes the existing abstract type (data type / processing type) based on the received operation, and stores it in the storage unit 140. If the user performs an operation not to edit, step S106 is skipped.

  Next, the editing unit 130 executes processing for setting the processing list 210 (step S107). Specifically, the contents of the current attention processing list are displayed on the display unit 170. Then, the edit input unit 120 accepts an operation for setting or changing the contents of the attention process list. Then, the editing unit 130 determines the contents of the attention process list based on the received operation, and stores it in the list storage unit 1420.

At this time, the editing unit 130 may check the contents of the attention process list and warn the user if there is a problem. For example, it is determined that there is a problem when there is a process in which the generated data is not used in a later process (there is no subsequent process using the output location address as the original data location). In addition, there is a process that has no previous process with the original data location as the output location, the generated data type of the process with the output location as the output location does not match the original data type of the process with the location as the original data location, etc. In this case, it is determined that there is a problem.
Then, the edit setting process ends.

In general, the processing list 210 generates and outputs a test procedure manual, and as shown in FIG. 7, a concrete data input unit 110, an internal data generation unit 150a, a selection unit 150b, a conversion unit 150c, a procedure manual generation unit 150d, and The processing system is described to include the procedure manual output unit 160. Each row of the processing list 210 in FIG. 4 corresponds to each unit as one processing unit.
In each unit, a concrete data input type 220i, an internal data generation type 220a, a selection type 220b, a conversion type 220c, a procedure manual generation type 220d, and a procedure manual output type 220o are stored in the type storage unit 1430 as corresponding processing types. ing. Details of each part will be described later.

A process of generating and outputting a test procedure manual using the process list determined by the edit setting process (procedure manual output process) will be described with reference to FIG.
When the user inputs information indicating the test procedure to the input / output unit 16, the procedure manual generation device 1 starts the procedure manual output process of FIG. This procedure manual output process is a process executed by the process execution unit 150.

  In the procedure manual output process, the information processing unit 11 selects a target process list to be executed from the process list 210 stored in the list storage unit 1420 (step S201). Specifically, the operation waits for the user to select an attention process list, and when the operation unit 14 receives the selection operation, the attention process list is selected based on the operation.

  Next, the load unit 1510 of the process execution unit 150 reads the unprocessed first line in the process list (in the example of FIG. 4, the #in line in the first loop, the # 01 line in the second loop, The same shall apply hereinafter. Then, the process (attention process) for that line is loaded (step S202).

Next, the acquisition unit 1520 (the concrete data input unit 110 in the first loop) acquires the original data (the concrete input data Din in the first loop) (step S203).
In the first loop, the concrete data input unit 110 extracts a line (#in in the example of FIG. 4) describing the concrete data input process in which the information processing unit 11 is at the head of the attention process list, and the “ This is realized by loading the processing type “operation” (concrete data input type 220i). As shown in FIG. 9A, the concrete data input type 220i includes information on the interface type, the input port number, and the input parameters. The input data type 220 _in (#Tin in the example of FIG. 4) is input from the input port. ) Describes the processing procedure for acquiring the concrete input data Din that matches. #Tin is a format _in which the input data type 220 _in is stored in a packet or the like.

When the concrete data input unit 110 acquires the concrete input data Din from the original data location (input port 1) as shown in FIG. 9 (b), the concrete data input unit 110 executes this process of adding a header to the input data. Data matching the type 220 _in is generated and transmitted to the output location (original data location of the internal data generation unit 150a). The output location (here, # x01) may be a part for storing an argument of the next process (internal data generation unit 150a), or may be a so-called I / O buffer.
In the second and subsequent loops, in step S203, the acquisition unit 1520 acquires original data (concrete data that matches the original data type) from the original data location.

  Next, the process execution unit 150 determines whether or not the internal process has been completed (step S204). Here, when the loaded process is a procedure manual output process (for example, the process of the #out line in FIG. 4), it is determined that the internal process has been completed.

  If the internal processing has not ended (step S204; NO), the loaded processing functions as the generation unit 1530 (processing entity). The generation unit 1530 generates generation data (for example, internal data D2) from the original data (for example, internal data D1) (step S205). At this time, the data type of the original data matches the original data type (for example, # T01) of the processing list. The generation unit 1530 can generate generated data that matches the type of generated data (for example, # T02) from arbitrary original data that matches the original data type.

  Then, the output unit 1540 outputs the generated data to the part of the output location (for example, # x02). The output location may be a part for storing an argument of the next process (for example, the selection unit 150b) or a predetermined part of the work memory.

Then, the process returns to S203, and the process on the next line in the attention process list is executed. Note that the process (step S207) when all the processes in the attention process list are completed will be described later.
Here, the process execution unit 150 typically implements the functions of the internal data generation unit 150a, the selection unit 150b, the conversion unit 150c, and the procedure manual generation unit 150d sequentially.

The internal data generation unit 150a is realized by the load unit 1510 loading the internal data generation type 220a as shown in FIG. At this time, the internal data generation type may have a pointer to reference data DC1 (for example, a fixed sentence added to a predetermined part of data).
The internal data generation unit 150a generates internal data D1 as shown in FIG. 10C from the data output from the concrete data input unit 110. At this time, the reference data Dc1 can be further used. Internal data D1 is consistent, for example, in the internal data type 220 ₁ as shown in Figure 10 (b).

  The internal data generation unit 150a stores the generated internal data D1 in the input work memory 1410a. The input work memory 1410a is a part of the work memory 1410. In the example of FIG. 4, the input work memory 1410a is the part of the address # x02.

As illustrated in FIG. 11, the selection unit 150b is realized by the load unit 1510 loading the selection type 220b. At this time, the selection type 220b may have a pointer to reference data Dc2 (for example, a selection table).
Selection unit 150b, the internal data _{D 1} of the input work memory 1410a, and generates an internal data D2 as shown in FIG. 12 (c). At this time, the reference data Dc2 can be further used. Internal data D2 are consistent for example in the internal data type 220 ₂ as shown in Figure 12 (a). Here, the internal data type 220 ₂ is the same as the internal data type 220 _1.

  In FIG. 11, in the input work memory 1410a and the output work memory 1410b, data corresponding to a certain piece of information (for example, one cell of the table) is indicated by a circle (or a polygon or an ellipse). The internal data D1 includes a plurality of pieces of information corresponding to test units. In the example of FIG. 10C, for example, d11 to d88 correspond to one test unit. For example, d12 indicates one test (test unit) to be executed with the parameters X1, X2, and Y1 to Y3 being ON and X3 being OFF. The same applies to FIG. 7 and the following drawings. Note that the pattern (solid color, diagonal line, or mesh line) and shape (circle, ellipse, or polygon) of each element indicate that the information has predetermined characteristics.

  The selection unit 150b executes selection by either a method using a selection table having the same structure as the internal data D2 and D3 (external specification method) or a method of performing selection based on a predetermined selection condition (inclusive specification method). May be. Here, the selection by the inclusive specification method is a method of specifying data having a predetermined property among the data in the internal data D2. In other words, the selection by the inclusive designation method is not to enumerate all the selected elements (extended designation method) but to define a property common to the selected elements. The inclusive specification method will be described later in detail.

An example of the extension method will be described. In FIG. 11, when FIG. 10C is input data, selection can be performed using a selection table (reference data Dc2) as shown in FIG. Selection table has a data having the same configuration as the data types of internal data D1 and D2 (internal type 220 ₁ and internal data type 220 _2), as shown in Figure 12 (a). In FIG. 12 (b), the selection table indicates 1 for selected data and 0 for unselected data. As a result of the selection, internal data D2 (FIG. 12C) is generated in which the value of the input test unit having no correspondence among the internal data D1 is NULL (symbol “−”).

The selection process aims at extracting necessary data from input data or deleting unnecessary data.
In the inclusive specification method, extraction is performed when the selection condition is satisfied (non-selection if not satisfied), and deletion is performed when the selection condition is not satisfied (selection if not satisfied). In the extension specification method, when selecting a cell with the cell value of the selection table turned ON (in the above example, the cell of the internal data D1 having a cell value of 1 in the selection table is selected and the cell value is 0) (Not selected) is extraction, and vice versa.

  The selection unit 150b outputs the internal data D2 generated by the selection process determined by the selection type 220b to the output location (# x03 in the example of FIG. 4). Here, # x03 is, for example, a part for storing an argument of the conversion unit 150c or a predetermined position in the work memory.

The conversion unit 150c is realized by the load unit 1510 loading the conversion type 220c as illustrated in FIG. At this time, the conversion type 220c may have a pointer to the reference data Dc3 (for example, a conversion table).
The conversion unit 150c executes the conversion process defined by the conversion type 220c using the internal data D2 output from the selection unit 150b as the original data, and generates the internal data D3.
Internal data D3 are consistent within the data type 220 ₃ as shown in FIG. 13 (b), for example. Here, the internal data type 220 _3, and is identical to the internal data type 220 _2.

Conversion unit 150c, a method of performing a method of using a conversion table having the same structure as the internal data D2 and D3 (internal type 220 ₂ and internal data type 220 ₃₎ (extensional measuring method), the conversion by a predetermined conversion conditions The conversion process may be executed by any of (inclusive specification method). Here, the conversion by the inclusive specification method is a method of converting data having a certain property into another data. In other words, conversion by the inclusive specification method is not to define conversion rules for all target elements (extended method) but to define conversion rules that apply to elements with common properties. . Specifically, for example, the data in the internal data D3 is converted by a function held by the conversion type 220c.

When the conversion unit 150c generates the internal data D3 from the internal data D2 by the conversion procedure stored in the conversion type 220c, the conversion unit 150c stores the generated internal data D3 in the output work memory 1410b.
The extension method of the conversion process will be described. In FIG. 13A, when FIG. 12C is input data, conversion can be executed using a conversion table (reference data Dc3) as shown in FIG. 13C. The conversion table has data having the same configuration as the data type of internal data D2 (internal data type 220 ₂ ). In the example of FIG. 13 (c), the conversion table, for each element of the internal data type 220 ₂ (each cell), a table, each conversion function (function F11~ function F88) it was defined. The conversion unit 150c converts the data of each cell of the internal data D2 with a function defined by the conversion table. For example, the data d12 of the coordinates (3, 4) of the internal data D2 in FIG. 12C is converted by the function F12 and arranged at the coordinates (3, 4) of the internal data D3. The data d13 of the coordinates (3, 5) of the internal data D2 is converted by the function F13 and arranged at the coordinates (3, 5) of the internal data D3. The same applies hereinafter. Note that the NULL value data is not executed for the coordinate value (3, 3), and the NULL value is also arranged in the generated data (internal data D3).
The output work memory 1410b is a part of the work memory 1410. In the example of FIG. 4, the output work memory 1410b is a part of address # x04.

The procedure manual generation unit 150d is realized by loading a procedure manual generation type 220d as shown in FIG. The procedure manual generation unit 150d uses the internal data D3 (internal data type 220 ₃ ) on the output work memory 1410b as original data, and the test procedure manual (internal data D4, internal data type 220 ₄ ) as shown in FIG. ) Is generated. At this time, the conversion type 220c may have a pointer to reference data Dc4 (for example, a correspondence table).
This test procedure manual data (internal data D4) shows how the test is actually performed from the result of selecting and converting the test factors included in the concrete input data Din as described above and designing the test. It is a list that is displayed in a form that is understood by humans (judgment criteria) and how to determine the test result.

In the example of FIG. 14C, the test procedure manual includes the following items.
(I) Preliminary preparation Indicates a process to be executed by a test performer to be ready for testing. In order to achieve the purpose of the test item, describe what preparations the tester will perform in advance (setting of set values, loading of input data, etc.). After completing the described preparations, the test object is ready for testing.
(Ii) Operation procedure Describes what operation the tester performs on the test target activated in the advance preparation (activation switch-on, selection of function 1 on the selection screen, etc.).
(Iii) Criteria Criteria for judging whether the result of the operation procedure is OK or NG. Describe what result (change / output, etc. that occurs when the operation procedure is executed) is OK, and describe what is NG (for example, NG, if function 1 is not activated and function 1 is If it starts, OK, etc.).
The procedure manual generation unit 150d uses a separately constructed database (for example, reference data Dc4), and the text of the items (i) to (iii) according to the combination of parameters (parameters 1 to 3 in the example of FIG. 14). Is generated by natural language processing. The texts of the items (i) to (iii) are preferably expressed as a description for executing and evaluating a test.

The text of items (i) to (iii) may be generated using any known method for generating text data based on the parameters. For example, text data to be applied to items (i) to (iii) for all parameter combinations may be prepared in the reference data Dc4, or text corresponding to the parameters may be embedded in a predetermined template. Alternatively, for each parameter, record a phrase suitable for the test target (for example, parameter 1: ON “function 1 of system A”, parameter 2: OFF “open dialog box and uncheck”, etc.) The text of each item may be synthesized by natural language generation for each test. Then, the procedure manual generation unit 150d records the generated text in the corresponding part of the test procedure manual (internal data D4).
This process is a kind of data conversion process that converts parameters (test factors) into text. However, the preparation and operation method for testing, the judgment criteria, and the format of the procedure manual for the output destination are the devices to be tested. Since it is specialized in the system, it is configured separately from the selection unit 150b and the conversion unit 150c.

The procedure manual generation unit 150d generates one line of procedure manual data for each piece of information (d11 to d88) indicating the test unit in the internal data D3. And each cell of the data matching the internal data type 220 _4, correspondence of each cell of the data that matches the internal data type 220 ₃ is defined inside the procedures generation type 220d. Alternatively, the reference data Dc4 may be defined. The procedure manual generation unit 150d creates a test procedure document by placing the information included in the internal data D3 in the test procedure document (internal data D4) for each test unit based on the correspondence between the data types. To do. At this time, no data is generated for the NULL value test unit.

  Returning to FIG. If it is determined in step S204 that the internal processing has been completed (step S204; YES), then the procedure manual output unit 160 outputs the output data Dout to the outside (step S207). More specifically, the information processing unit 11 extracts a line (#out in the example of FIG. 4) describing the procedure manual output process at the end of the attention process list, and the processing type (procedure manual) of that line. The output type 220o) is loaded and the process of the procedure manual output unit 160 is executed. As shown in FIG. 15A, the procedure manual output type 220o includes information on the interface type, input port number, and input parameters, and can be output by storing the original data (internal data D4) in a packet or the like. As a format (#Tout in the example of FIG. 4), the data is output to an external device through an output location (here, a serial port).

  When the test procedure manual is output to the outside in step S207, the procedure manual output process ends.

  The processing types and data types stored in the type storage unit 1430 can have a superclass / subclass relationship depending on the degree of abstraction. For example, as the selection type 220b, a superclass that defines only functions common to all selection processes can be prepared, and a subclass corresponding to a selection process having a predetermined characteristic (for example, all selection) can be defined. By defining a superclass and a subclass, it is not necessary to repeatedly define the same function. In addition, if the superclass is changed, the functions of all subclasses can be changed at the same time, greatly reducing the labor required when changing the system.

  The object abstracted as a data type abstracts not only the processing unit such as internal data / input / output data but also each element included in the abstract data type. That is, when a factor included in a certain data type is data having a tree structure, the tree structure itself and elements constituting the tree are abstracted and stored in the type storage unit 1430 as a data type.

  The procedure manual generation apparatus 1 can have various processing structures (abstract structure and concrete structure) depending on the setting contents of the processing list and the processing type / data type. A setting example of the procedure manual generation apparatus 1 and functions in that case will be exemplified below. It is assumed that the procedure manual generation apparatus 1 stores in advance in the storage unit 140, as a template, a processing type / data type for processing shown in the following setting example and a processing list defining processing shown in the setting example.

(Setting example 1)
Setting example 1 is a setting example suitable for the case where the input data type 220 _in can be used as an internal model without conversion _{in the} system configuration as described above. The selection unit 150b and the conversion unit 150c of setting example 1 have a processing structure as shown in FIG.
In setting example 1, the internal models (internal data types 220 _{1 to} 220 ₄ ) are common. The internal model in this case is, for example, a table in which a set of factors and actions for the factors are described.
In setting example 1, the selection unit 150b selects data as the reference data Dc2 using a selection table as shown in FIG. Specifically, the internal data D1 is generated by copying the internal data D1 as it is except that the value of the cell in which the non-selection (for example, 0) is stored in the selection table is NULL. Also, the conversion unit 150c does not perform conversion, and stores the internal data D2 as it is in the output work memory 1410b as internal data D3.
Setting example 1 is effective when a test procedure manual can be created only by selection without converting input data.

(Setting example 2)
Setting example 2 is a setting example in which data is converted on a one-to-one basis by the conversion unit 150c. As in setting example 1, in the system configuration as described above, it is assumed that the input data type 220 _in can be used as it is as an internal model.
The selection unit 150b and the conversion unit 150c of setting example 2 have a processing structure as shown in FIG.

  In this setting example, the selection unit 150b transmits the message to the conversion unit 150c as it is. The conversion unit 150c converts each cell of the internal data D1 as necessary using a conversion table as shown in FIG. 17B, and stores it in the output work memory 1410b.

Conversion using a conversion table means that if a cell value (or part of it) is a value registered in the column of the conversion table before conversion (“symbol” in FIG. 17B), This means that the portion is converted after conversion (“character string” in FIG. 17B). Therefore, the conversion table stores information before conversion and information after conversion in association with each other.
In the example of FIG. 17B, when a symbol “◯” is included in a certain cell, that portion is converted into a character string “activation”.

In this setting example, in the concrete input data, the level of the factor and the cell value (in the example of FIG. 5C, the state names a to e in the data cell and the system output names out1 to out5) are described by symbols. Can be used for batch conversion to improve readability. For example, a (out1) can be converted into a stopped state (a startable lamp is lit). At this time, a = stopped state and out1 = converted to startable lamp lighting.
Further, for example, this setting example can be used for conversion such as character code conversion (JIS to EUC) or insertion of a delimiter (specific symbol / character => specific symbol / character + delimiter) for concrete input data. Furthermore, this is effective when the name of a process is changed at the time of upgrading the system and when the name is changed to a new name at once.

Since this setting example is a simple expression method conversion, reverse conversion (inverse conversion) can also be realized. That is, conversion from the test procedure manual to concrete input data is also possible.
By applying this, the test result (OK / NG) of the test procedure manual is converted back to the internal data type (internal data type 220 ₁ ), and the test result can be used with the internal data type. For example, if a process for visualizing the distribution of NG (defects) for each test viewpoint is defined for the internal data type, the test coverage monitor can be efficiently executed regardless of the difference in the test procedure manual. Similarly, it is possible to effectively display the test result (OK / NG) and test execution date (calendar date) of the test procedure manual as a time-series graph on the test work progress management table (X chart).

(Setting example 3)
Setting example 3 has a processing structure for normalizing the test viewpoint (factor level).
In this setting example, as shown in FIG. 18A, the information (factor level) of the internal data D1 is divided into the internal data D3 by the conversion unit 150c.
In this setting example, the selection unit 150b performs full selection or partial selection. The conversion unit 150c performs normalization of each level of the factor (decomposition from one level into a plurality of levels), and eliminates redundancy.

On the other hand, as shown in FIG. 18B, the conversion unit 150c of this setting example generates internal data D3 obtained by dividing the factor of the selection result (internal data D2) of the selection unit 150b.
The conversion unit 150c may perform factor division using any known method for generating a plurality of values from one value, but here, a division table (reference data Dc3) as shown in FIG. ).
In this setting example, normalization conversion is a correspondence relationship between physical one-to-many conversion (level code delimiter method) or semantic one-to-many conversion. This normalization process is a process of semantically decomposing input data (separating levels). Here, “semantic decomposition” means, for example, dividing “acceleration forward” according to meaning into “normal state”, “forward direction”, “during speed addition”.
For this purpose, a plurality of words are registered in the reference data Dc3 so that the concept of the word related to the test target system appearing in the input data can be divided and a factor corresponding to the divided concept can be generated. For example, when the concept of “driving” a car is divided into “state”, “moving direction”, and “speed change”, “normal” “failure” (partly broken but used) "" Repair (cannot be used during tire replacement) "," Moving direction "," Front "," Back ", and" Speed change "," Adding (accelerating) " Three words “subtracting (decelerating)” and “0 (constant speed or stopped)” are registered. At the time of conversion, words corresponding to the three factors (“normal state”, “forward”, “adding speed”) are extracted from the words appearing in the input data (accelerating forward in the above example).

  The purpose of the normalization process in this setting example is the same as the normalization process in the database. That is, it is a process of separating the test viewpoint so that it becomes a single concept that does not overlap with other test viewpoints.

In this setting example, when the test viewpoints (factor levels) specified in the design specifications (concrete input data) imply (mix) multiple test viewpoints, division (normalization) into independent test viewpoints is performed. Can be used to do.
For example, when designing a test by mixing a plurality of factors, it is necessary to make the levels of any two factors orthogonal in order to prevent the test items from leaking or overlapping.
Specifically, when a certain level of a factor has a plurality of meanings, it is necessary to separate them so that they do not overlap each other and display them on a tabulation table (pivot table).
This setting example can be used for semantic separation (linear independence) in order to see the interaction of the levels of each factor in such a case.

(Setting example 4)
In setting example 4, the test viewpoint (factor) is divided into a plurality of groups.
In this setting example, as shown in FIG. 19A, two selection units, a selection unit 150b1 and a selection unit 150b2, are defined.
The selection unit 150b1 and the selection unit 150b2 may be a functional unit of the selection unit 150b activated as one process on the processing list. In this case, the conversion unit 150c and the output work memory are also divided into functional units.
Alternatively, they may be defined separately on the processing list. In this case, two selection processes (corresponding to the selection unit 150b1 and the selection unit 150b2) that define the input work memory as the original data location are defined in the processing list.

As shown in FIG. 19B, the selection unit 150b1 and the selection unit 150b2 interpret the internal data D1 in two as shown in the internal data D2a and the internal data D2b. Then, two internal data are generated based on the interpretation result.
Further, conversion units 150c1 and 150c2 are defined which respond to the output of each selection process. As illustrated in FIG. 19B, the conversion unit 150c1 generates internal data D3a from the internal data D2a. The conversion unit 150c2 generates internal data D3b from the internal data D2b. The conversion units 150c1 and 150c2 output the generated internal data to the output work memory 1410b1 and the output work memory 1410b2, respectively. The procedure manual generation unit 150d generates a procedure manual based on the internal data stored in the output work memory 1410b1 and the output work memory 1410b2. At this time, the procedure manual generation process is defined on the process list as a function having two arguments (a process using the output work memory 1410b1 and the output work memory 1410b2 as the original data location).

At this time, each element of the internal data D1 is always converted to zero or one output data, and input data is not selected redundantly by a plurality of selection processes. For example, the selection unit 150b1 executes the selection process with a selection rule as illustrated in FIG. The actor risk (*) in FIG. 19C means a wild card, and an arbitrary character string starting from P1 is selected from each line of the internal data D1. Then, internal data D2a is generated with P1 as factor 1 and the other part as factor 2. The conversion rule may be recorded in the reference data Dc2a, for example.
Similarly, the selection unit 150b2 selects an arbitrary character string starting from P2 in each row of the internal data D1 according to a selection rule as shown in FIG. Then, internal data D2b is generated with P2 as factor 1 and the other part as factor 2. The conversion rule may be recorded in the reference data Dc2b, for example.

The conversion unit 150c1 executes the conversion process according to a conversion rule as shown in FIG. The actor risk in FIG. 19 (e) means that the content of factor 1 is not questioned for conversion. The conversion unit 150c1 converts the line 2 of the internal data D2a to a line in which the factor 2 is a character string other than the actors (for example, “generation”), and all the lines in which the display content is a character string (for example, the factor 2 is “generation”). Internal data D3a to which “A1”) is added is generated.
Similarly, the conversion unit 150c2 executes the conversion process according to a conversion rule as shown in FIG. The conversion unit 150c2 converts the line of the internal data D2b into a line in which the factor 2 is a character string other than the actors (for example, “generation”), and all the lines in which the display content is a character string (for example, the factor 2 is “generation”). "B1") is added to generate internal data D3b.

This setting example is suitable when it is desired to form a test viewpoint of input data in a matrix or when it is desired to separate (divide) factors into a plurality of groups.
For example, it is used when you want to configure a pivot table by dividing the parameter list into X and Y axes. When designing a test, there is a case where it is desired to create a list (decision table) regarding the combination of test viewpoints and operation results and to look over the whole picture. The format of the list is a matrix format in which test viewpoints (factors) are placed on the vertical and horizontal axes, and the operation results are described at the intersections (each cell) of the test viewpoints. It is necessary to divide the factors into two groups, the vertical axis and the horizontal axis. According to this setting example, the process of dividing can be realized.

  Similar processing can also be realized with the processing configuration shown in FIG. In this case, the selection unit 150b performs full selection, and sets the processing list so that the conversion unit 150c has two outputs (output work memories 1410b1 and 1410b2).

(Setting example 5)
In setting example 5, a plurality of test viewpoints included in the input data are combined into one test viewpoint.
In this setting example, as shown in FIG. 21A, the selection unit 150b transmits the internal data D1 as it is to the conversion unit 150c as the internal data D2. In addition, the conversion unit 150c merges a plurality of test viewpoints by executing a merge process that combines a plurality of levels into one.

  Specifically, as shown in FIG. 21B, a combination of rows of internal data D2 (X2B and X2C rows, X4B and X4C rows) is converted into one row (in each case X2C rows, X4B row).

  Therefore, the conversion unit 150c uses a merge rule table (reference data Dc3) as shown in FIG. The merge rule table stores a combination of data before conversion and data after conversion in association with each other. However, the present invention is not limited to this, and a known rule for generating one post-conversion data from a plurality of pre-conversion data can be used as the merge rule.

This design example is suitable when the design specification (input data) alone is not an actual test viewpoint, but if it is combined, information that meets the actual requirements is included.
For example, there may be a case where the level of the factor is a plurality of set data and it is desired to handle the set data semantically. Specifically, the input data is triplet data (for example, X, Y, Z), meaning one matter (for example, space coordinates), and semantic data (for space This is a case where a test is to be performed by specifying coordinates).

  Note that in the case of settings in which information is not lost by merging, this setting example can be applied to reverse conversion (inverse conversion). That is, conversion from the test procedure manual to concrete input data is also possible.

(Setting example 6)
In setting example 6, one test procedure document is generated from a plurality of input data.
In this setting example, as shown in FIG. 22A, a concrete data input unit (concrete data input units 110a and 110b), an internal data generation unit (internal data generation units 150a1 and 150a2), an input work memory (input work memory) 1410a and 1410b), two combinations of selection units (selection unit 150b1 and selection unit 150b2), and conversion units (conversion unit 150c1 and conversion unit 150c2) are defined.

  Therefore, two sets of concrete data input processing, internal data generation processing, selection processing, and conversion processing are defined in the processing list 210. At this time, the conversion process is, for example, a full selection process. The output location of the two conversion processes is a position indicating the same internal data D3 in the work memory 1410b.

As a result, as shown in FIG. 22B, for example, two internal data (internal data D1a and D1b) are stored on the input work memory. Then, the information contained in the internal data D1a and D1b, the conversion unit 150c1 and the conversion unit 150C2, the mold storage section 1430 generates the internal data D3 disposed at a predetermined portion on the internal data type 220 ₃ store.

For this reason, the conversion unit converts and arranges information using, for example, an arrangement conversion table (reference data Dc3) as shown in FIG.
The arrangement conversion table in FIG. 22C specifies that factor A and factor B of the original data are arranged linearly as factor C on the generated data.

This setting example is suitable for adding new contents based on a test viewpoint of a design specification (input data). For example, when test information to be actually executed is distributed in multiple design specifications, and the information is not organized, multiple data are collected based on some connected information on one test procedure table. This is the case of synthesis.
Specifically, in a system in which a plurality of outputs can be obtained by inputting a combination of predetermined input data, when a decision table is created by combining the obtained outputs, or a process (function) in which a plurality of data are collected You may want to create an input data table as a test procedure manual to enter. In addition, when design information as a test viewpoint is a plurality of lists for each piece of information, there may be a case where a plurality of lists are integrated to generate a table that can grasp one whole picture.
Also, it can be used when it is desired to insert (add) a certain fixed word such as a common confirmation item or a common process at the start or end of a test regardless of the selected item. Furthermore, when you want to merge multiple tables according to conditions into a single table including conditions, or when you want to test matrix operations (addition, inner product, etc.) between two data using two matrix data as inputs It can also be used when it is desired to perform some operation on two input data.

(Setting example 7)
Also, if the input data type 220in and the internal data type ₂₂₀ 1 to 220 _n are different, it is effective to set as shown in FIG. 23.
In this setting example, the internal data generation unit 150a is, by changing the structure of the data transmitted from the concrete data input unit 110, the data that matches the internal type 220 ₁ (internal data D1).

Then, the selection unit 150b executes a match search process using the selection table (reference data Dc2). Selection table has the same structure as the internal data type 220 ₁ and 220 ₂ is data such as illustrated in Figure 12 (b).
Note that the conversion unit 150c does not have to execute the conversion process.

This setting is used when the input data type is different from the internal data type, and there is information that can be used in the design specification (input data), but it is difficult to specify the conditional expression if it contains unnecessary information. Is preferred.
Specifically, it is suitable for the case where it is desired to perform an additional test related to the weak point by analyzing the test result, and to generate a test case around the weak point and its surroundings.

(Setting example 8)
Furthermore, instead of determining the correspondence of the internal data D1 by a database or the like as described above, it is possible to set the selection unit 150b to select according to an arbitrary condition (predetermined condition) (FIG. 24).
In this case, the selection unit 150b determines whether the internal data D1 is selected or not based on a predetermined determination criterion (for example, whether or not the value is within a predetermined range).
Then, the part of the non-selected data is set to NULL, and the selected data is copied to the corresponding part of the internal data D2.
In this setting example, the conversion unit 150c does not execute the conversion process.

  This setting example is suitable when selection of input data cannot be realized by simple filter processing. For example, the selection condition can be expressed by a combination of threshold values or a mathematical expression. It can also be used to delete any software code (codes such as #define and #end) included in the input data.

(Setting example 9)
The setting example including the selection unit 150b and the subsequent conversion unit 150c has been described above, but the setting example of the present embodiment is not limited to this.
For example, as shown in FIG. 25, a configuration in which the selection unit 150b is followed by the conversion unit 150c can be set. In this case, a selection process may be arranged after the conversion process in the process list.
This setting example is suitable when the input data is first converted and selection (determination) is desired for the conversion result.

(Setting example 10)
As an extension of setting example 9, a plurality of selection units (selection units 150b1 and 150b2) may be arranged behind the conversion unit 150c (FIG. 26).
In this setting example, multiple selection processes are performed on input data.
This setting example is suitable when it is desired to further narrow down the test viewpoint with respect to the test procedure document generation system already constructed in the first embodiment. That is, a desired process (reduction of the number of test cases, etc.) can be realized only by adding a selection process without designing a new process structure from the position.

(Setting example 11)
Further, a plurality of conversion units (conversion units 150c1 and 150c2) may be arranged (FIG. 27).
In this setting example, the conversion processing is performed a plurality of times on the input data.
This setting example is suitable for the case where it is desired to further convert the test viewpoint to the test procedure document generation system that has already been constructed in the first embodiment. That is, it is not necessary to design a new processing structure from scratch, and a desired process (two-stage conversion or the like) can be realized by adding a conversion process.
That is, the past test procedure manual generation system can be reused.

  As described above, according to the procedure manual generation apparatus 1 of the present embodiment, since the procedure manual is generated by sequentially executing the processes defined for the data abstract type, the specific number / dimension of the data Regardless of the number, procedures can be generated on the same system. That is, the procedure manual can be generated efficiently.

  Further, the procedure manual generation apparatus 1 of the present embodiment includes a data structure (internal model, data type) abstracted for each test viewpoint and an abstract process (processing type). Therefore, there is no need to set different processing structures according to the implementation of the system to be processed. In the test procedure manual automatic creation system based on the conventional method, much work (correction cost, time) is required for work (physical system construction, programming work, data preparation) for realizing the automation system. In the present embodiment, this labor can be reduced. For this reason, the productivity improvement effect by the automatic creation of the test procedure manual is not offset by the realization cost of the automation system, and the total cost reduction effect (system construction + procedure manual generation) can be realized immediately.

  In addition, even when the test requirements / system configuration changes greatly, a generation system that meets the new requirements can be constructed with minimal effort for changing the processing type and data type.

  Even if the created test procedure manual automatic creation system (process list) is to be deployed as a success example to other different systems, it is only necessary to make necessary changes to the process type, data type, and process list, making it easy to divert Become.

  That is, according to the procedure manual generation apparatus 1 of the present embodiment, a test procedure manual generation system can be constructed simply and quickly. In addition, reusability of test design assets is high. In addition, since the data type is described in a domain-specific language (DSL) instead of a general-purpose modeling language such as UML, an existing design specification can be used as input data as it is. Therefore, it is not necessary to rewrite the existing design specifications in UML. In addition, the application range of the generation system can be expanded. Note that it is also possible to support such setting by storing a processing type / data type template for each DSL in the storage unit 140 and constructing the processing execution unit 150 with a processing system capable of interpreting a plurality of DSLs. . Further, a test procedure generation procedure like the above setting example for a known existing system may be recorded at the time of factory shipment. According to such a configuration, the user can create a test procedure manual for an existing system without setting the user himself / herself. Moreover, a desired test procedure document generation system can be created by modifying the default setting example as necessary.

In the procedure manual generation apparatus 1 of the present embodiment, not only internal data / input / output data is converted to abstract data types but also each element included in the abstract data type is abstracted. As a result, when the target data is changed, it is sufficient to rewrite the abstract type.
Further, not only the input data but also the output format of the test procedure manual (output data) is abstracted (metadataized), thereby corresponding to an arbitrary test procedure manual format.

  Furthermore, input / output (concrete data input part, procedure manual output part) is also abstracted using processing types. For this reason, the change of the interface means can be handled only by rewriting the processing type.

  The test procedure manual automatic creation system according to the present invention defines a series of selection / conversion processes from functional requirements to test procedure documentation as an abstract type, and determines the processing order by a processing list. Therefore, the configuration / function can be rewritten by a simple method of editing an abstract type or a processing list. That is, a desired process can be realized without editing the program itself. Thus, a process for generating a procedure manual is arbitrarily configured, or various test procedure manual automatic creation systems can be easily realized by combining a plurality of conversion processes.

In particular, by separating the easy-to-abstract process and the difficult-to-abstract process in the procedure manual generation system, the part that needs to be redesigned can be minimized even if the test object is different.
In the above embodiment, it is difficult to conceptualize the procedure manual generation process executed by the procedure manual generator 150d. The procedure manual generation process must generate text indicating the actual test procedure (operation) based on the value of the factor. For example, the operation of the mobile phone and the operation of the television are completely different, so this process is an abstract type. This is because it is difficult to make a superordinate concept.
On the other hand, the selection process executed by the selection unit 150b and the conversion process executed by the conversion unit 150c depend only on the test viewpoint, and do not depend on individual devices or systems to be tested. For example, mobile phones and televisions have control structures such as state transitions and competition tables, which can be symbolized (abstracted). Therefore, by using an abstract type, it is possible to configure a processing system that does not depend on individual devices or systems to be tested. By making this process a high-level concept using an abstract type, an existing successful procedure manual generation system or template can be used.
That is, in this embodiment, a procedure manual generation process (a process executed by the procedure manual generation unit 150d), which is a process that is strongly model dependent, is described specifically for the test target, and a process that is weak in model dependency (selection process, conversion process). ) To create a high-level concept by abstract type, achieve efficient generation of test procedures.

  The procedure manual generation apparatus 1 divides the processing type (particularly the selection type / conversion type) / data type according to the above setting example into a lower class from a higher class according to the degree of abstraction, and stores it in the storage unit 140 in advance as a template. ing. Therefore, the user can easily construct a processing system as shown in the above setting example using a template.

(Modification)
As mentioned above, although embodiment of this invention was described, this invention is realizable also in other embodiment.

For example, in the above-described embodiment, the selection unit and the conversion unit perform the processing independently, and the conversion unit is executed after the processing of the selection unit is completed. However, the present invention is not limited to this, and the selection unit and the conversion unit may generate internal data (internal data D _n ) stored in the output work memory in conjunction with each other.
For example, the following configurations are possible.
The selection unit 150b sets one data unit (cell or the like) on the internal data D1 as a unit of attention. Then, which part on the internal data Dn corresponds to the unit of interest is selected using a correspondence table or the like. If there is no corresponding part, the next unit of interest is selected.
On the other hand, when there is a corresponding part, information on the unit of interest is transmitted to the conversion unit 150c together with information on the correspondence destination (coordinates on the internal data Dn). The conversion unit 150c converts the information transmitted according to a predetermined conversion rule, and arranges the information in the corresponding part.

  In addition, the hardware configuration and the flowchart described above are merely examples, and can be arbitrarily changed and modified.

  The central part that performs processing for generating a procedure manual composed of the information processing unit 11, the main storage unit 12, the external storage unit 13, and the like is realized by using a normal computer system, not a dedicated system. Is possible. For example, a computer program for executing the above operation is stored and distributed in a computer-readable recording medium (flexible disk, CD-ROM, DVD-ROM, etc.), and the computer program is installed in the computer. You may comprise the center part which performs the process for a change reconstruction image generation. Further, the computer program may be stored in a storage device included in a server device on a communication network such as the Internet, and the procedure manual generation device may be configured by being downloaded by a normal computer system.

  When the function of the procedure manual generation device is realized by sharing of the OS (operating system) and application program, or by cooperation between the OS and application program, only the application program portion is stored in a recording medium or storage device. Also good.

  It is also possible to superimpose a computer program on a carrier wave and distribute it via a communication network. For example, the computer program may be posted on a bulletin board (BBS: Bulletin Board System) on a communication network, and the computer program may be distributed via the network. The computer program may be started and executed in the same manner as other application programs under the control of the OS, so that the above-described processing may be executed.

DESCRIPTION OF SYMBOLS 1 ... Procedure manual production | generation apparatus 11 ... Information processing part 12 ... Main memory part 13 ... External storage part 14 ... Operation part 15 ... Display part 16 ... Input / output part 17 ... Internal bus 18 ... Program 110 ... Concrete data input part 120 ... Editing Input unit 130 ... Edit unit 140 ... Storage unit 1410 ... Work memory 1410a, 1410a1, 1410a2 ... Input work memory 1410b, 1410b1, 1410b2 ... Output work memory 1420 ... List storage unit 1430 ... Type storage unit 150 ... Processing execution unit 150a, 150a1 , 150a2 ... internal data generation unit 150b, 150b1, 150b2 ... selection unit 150c, 150c1, 150c2 ... conversion unit 150d ... procedure manual generation unit 1510 ... load unit 1520 ... acquisition unit 1530 ... generation unit 1540 ... output unit 160 ... procedure manual output Unit 170 ... display unit 210 ... processing list 2 0 ... abstract ₂₂₀ 1 to 220 n _... internal type 220i ... concrete data-entry 220o ... instructions output type 220a ... internal data generation type 220b ... selective 220c ... transform 220d ... instructions generated type 220In ... input data type 220out: Output data type Din: Concrete input data D1-Dn, D1a, D1b ... Internal data Dout ... Output data Dc1-Dc4, Dc2a, Dc2b, Dc3a, Dc3b ... Reference data

Claims (12)

Information indicating a process for generating generated data from original data, an original data type that is an abstract type of the original data to be processed, a method for generating the generated data from the original data, and the generated data A list storage unit that stores a processing list that is a list of processing information associated with a generated data type that is an abstract form of
An acquisition unit that acquires input data of an input type that is a data type included in the original data type, including information on a test procedure;
The processing stored in the processing list stored in the list storage unit is executed in the order determined by the processing list using the generated data generated as a result of the processing as the original data of the subsequent processing, and the acquisition is performed. A generation unit for generating a test procedure document from input data acquired by the unit;
An output unit for outputting the test procedure manual generated by the generation unit;
A procedure manual generation apparatus characterized by comprising: In the processing list stored in the list storage unit, the processing information is from processing that uses the input type input data as the original data to processing that uses the data type of the test procedure manual as the generated data type. Arranged so that the generated data type of the previous process becomes the original data type of the subsequent process,
The procedure manual generation apparatus according to claim 1. A processing data type that is an abstract type of data to be processed in the processing list, and a type storage unit that stores a processing type that is an abstract type of the processing;
The processing information of the processing list stored in the list storage unit is information indicating a processing type stored in the type storage unit,
The original data type and the generated data type of the processing list are processing data types stored in the type storage unit, respectively.
The procedure manual generation apparatus according to claim 1 or 2, characterized in that In the input data, one or more test factors and one or more level values for the test factors are defined,
In the test procedure manual, a plurality of test execution procedures corresponding to combinations of the test factor level values are described,
The processing type is a processing type of selection processing for generating the generated data by extracting or deleting test information corresponding to any of the test factor, the level value, and the combination of the level values included in the original data And a processing type of conversion processing for converting the test information to generate the generated data,
The procedure manual generation apparatus according to claim 3, wherein: The test execution procedure described in the test procedure manual includes at least one of a character string explaining the preliminary preparation of the test, a character string explaining the test operation procedure, and a character string explaining the test criterion. Including
The processing type is different from the processing type of the selection processing and the processing type of the conversion processing, and a character that generates a character string to be described included in the test procedure document from generated data generated as a result of the selection processing or the conversion processing Further includes the processing type of the column generation process,
The procedure manual generation device according to claim 4, wherein: A change accepting unit that accepts information instructing to change the processing type or the processing data type stored in the type storage unit;
A type changing unit that changes the processing type or the processing data type based on the information received by the change receiving unit;
The procedure manual generation apparatus according to claim 5, further comprising: An edit reception unit for receiving information instructing editing of the processing list;
An editing unit that edits the processing information of the processing list by combining the selection processing, the conversion processing, and the character string generation processing based on information that instructs editing of the processing list received by the editing reception unit. ,
The procedure manual generation apparatus according to claim 6, further comprising: The processing type or processing data type that is an abstract type stored by the type storage unit includes a parent type that is an original abstract type and a child type that inherits the characteristics of the parent type.
8. The procedure manual generation apparatus according to claim 3, wherein The processing data type or the processing type stored in the type storage unit is described in a predetermined domain specific language,
The generation unit interprets the processing data type or the processing type described in the predetermined domain specific language and executes the processing.
9. The procedure manual generation device according to claim 3, wherein The process list stored in the process list includes processes defined in the process information and defined to execute the process in a self-recursive manner.
The procedure manual generation device according to claim 1, wherein Information indicating a process for generating generated data from original data, an original data type that is an abstract type of the original data to be processed, a method for generating the generated data from the original data, and the generated data Process list that is a list of process information that associates the generated data type that is an abstract form of
Obtaining input data of the input type that is the data type included in the original data type, including information on the test procedure,
The process stored in the acquired process list is executed in the order determined by the process list using the generated data generated as a result of the process as the original data of the subsequent process, from the acquired input data Generate a test procedure,
Outputting the generated test procedure manual;
A method for generating a procedure manual. On the computer,
Information indicating a process for generating generated data from original data, an original data type that is an abstract type of the original data to be processed, a method for generating the generated data from the original data, and the generated data A function that acquires a processing list that is a list of processing information that associates a generated data type that is an abstract form of
A function of acquiring input data of an input type that is a data type included in the original data type, including information of a test procedure;
The process stored in the acquired process list is executed in the order determined by the process list using the generated data generated as a result of the process as the original data of the subsequent process, from the acquired input data The ability to generate test procedures,
A function for outputting the generated test procedure;
A program characterized by realizing.

Images