JPH04237342A - Program testing device - Google Patents

Abstract

PURPOSE:To improve the test completion rate by the small number of tests by generating a fuzzy rule from a fuzzy variable in a branch condition expression in a program and forming a test parameter by fuzzy inference. CONSTITUTION:After loading data formed from an execution program, a source program, a load module, etc., previously stored in an external storage device 15 to an internal storage device 14 based upon a command inputted from a keyboard 18, a work station 10 acts as a program testing device as a whole while controlling a debugging executing device by executing the program by an arithmetic and control unit (ACU) 13. A fuzzy rule is formed from a fuzzy variable between the independent variables to be the right side value and left side value of the branch condition expression in the program and a test parameter for executing the test of an untested route in the program is generated by fuzzy inference to which the fuzzy rule is applied.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program testing device for generating test parameters for testing developed software programs.

0002

[Prior Art] As a background for generating test parameters for testing a program, it is necessary to reduce the number of test runs.
There is a need for a means for dynamically automatically generating test parameters that can be expected to achieve a high test coverage rate (coverage value) within a required amount of time. In addition, large-scale online real-time
For systems, a development method is used in which modules that have undergone individual testing are combined as parts to construct a single system, and as a result, testing that focuses on control structures has become increasingly important. Conventionally, traditional test parameter creation guidelines include highly random data or data that includes all combinations of unique values.
Qualitative attribute definitions are commonly used.

0003

[Problem to be solved by the invention] In the case of data with qualitative attribute definitions as described above, in order to generate test parameters, it is necessary to digitize the data, and the amount of this data is enormous, so it is not practical. The problem is that it is not accurate. In addition, although empirical knowledge has been accumulated regarding the effects of unique combinations of test parameters on the control structure, it is difficult to quantify this knowledge, making it difficult to apply it to the automatic test parameter generation process. It has some problems. Furthermore, the empirical testing method has the problem that when the test coverage approaches 100%, it becomes extremely difficult to generate effective test parameters, which increases the cost of ultra-high quality systems. Therefore, this invention
In addition to solving the above-mentioned problems, it is possible to effectively generate test parameters by effectively utilizing the experiential knowledge obtained from debugging and testing similar programs, and to increase test coverage with fewer tests. The purpose of the present invention is to provide a program testing device that is capable of processing large-scale programs and is also effective for large-scale programs.

0004

[Means for Solving the Problems] This invention generates fuzzy rules from fuzzy variables between the right-hand side value of a branch conditional expression in a program and the independent variable of its left-hand side value, and tests untested paths of the program. The present invention is characterized by a program testing device that generates test parameters for execution by fuzzy inference applying the fuzzy rules.

[0005]

[Operation/Effect] According to the present invention, by registering the experiential knowledge obtained through debugging and testing similar programs in the form of fuzzy variables, the use and quantification of experiential knowledge is simplified, effective and efficient. It is possible to generate test parameters. In addition, when generating test parameters by giving setting values with large margins step by step for a program that has significant nonlinearity and unbiased test data is not very effective, the generation process can be made effective and the bias can be reduced. The test coverage rate (coverage value) can be increased with a small number of tests compared to a case where there are no test parameters, and as a result, large-scale programs and programs for ultra-high quality systems can be efficiently generated at a high rate.

[0006]

DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described below in detail with reference to the drawings. The drawing shows a program testing device, and in FIG. 1, the program testing device includes an engineering workstation 10 using a general-purpose computer, a terminal device 11 that allows an operator to directly access the workstation 10, and a workstation. 10, and a debug execution device 12 for debugging a debug target program developed using the debugger 10.

The above-mentioned workstation 10 is mainly equipped with an arithmetic and control unit 13 using a microprocessor, an internal storage device 14 consisting of a RAM, an external storage device 15 such as a hard disk drive, and an interface circuit for peripheral devices. The input/output device 16 is configured by being connected via various buses 17, and the terminal device 1 described above
1 and the debug execution device 12 are the input/output device 1 described above.
It is connected via 6.

The terminal device 11 described above includes a keyboard 18 that allows direct access to the workstation 10, and a display device 19 such as a CRT that displays the data processing status within the workstation 10 in a visible manner. After configuring the program and loading data created from an execution program such as a compiler or assembler, a source program, a load module, etc. stored in advance in the external storage device 15 into the internal storage device 14 by inputting a command from the keyboard 18. By causing the arithmetic and control unit 13 to execute a program, the workstation 10 as a whole operates as a program testing device while controlling the debug execution device 12.

The debug execution device 12 is located between a device to be debugged 20 using a microprocessor as a control unit that runs a program to be debugged, and the device to be debugged 20 and the workstation 10, and is located between the device to be debugged 20 and the workstation 10, and is connected to the microprocessor of the device to be debugged. The debugged device 2 instead of
0, and displays and updates the contents of the memory on the debugged device 20 in response to commands given from the workstation 10 side through the input/output device 16, or After executing various controls such as executing and stopping the program on the debug target device 20, the results are returned to the workstation 10, thereby allowing the workstation 10 to perform test processing and debugging of the source program using a high-level language. processing.

Next, the program test operation of the device to be debugged 20 will be explained based on the data flow chart of FIG. When the program of the debugged device 20 is input using the keyboard 18 of the terminal device 11 (step n1
), the editor edits the source program file (step n2) and stores it (step n3).

The compiler or assembler translates the high-level language of this source program into machine language to generate object code (step n4) and stores it (step n5). Based on the data stored in the library file (step n6), the linkage editor generates a load module for operating the debug target device 20 from the object code described above (step n6).
7), store this (step n8). Then, this load module is loaded into the emulator 21 of the debug execution device 12 (step n9), and the debug target device 2
Operate 0.

Similar to a well-known compiler, a syntax analysis means extracts a branching conditional expression from the source program edited in step n3 described above (step n10), and creates a table of branching conditional expressions and their independent variables (Fig. 5) and store it (step n11).

A large number of the above-mentioned branch conditional expressions are formed in the source program, and each expression Sn has a setting value Yn on the right side of the branching conditional expression Sn, as shown in FIG.
Also, the lvalue Xn is the independent variable, and the branch direction is YE
It is given by S, NO.

The test case table of the branch conditional expression and independent variables edited in steps n10 and n11 above is as follows:
As shown in FIG. 4, each branch conditional expression Sn, the test result of the path of each branching conditional expression Sn, and whether or not it has been tested indicating whether a predetermined test coverage rate has been obtained are recorded. The branching conditional expression Sn that executes inference targets untested paths.

For example, test case No. 1 in FIG.
This is an untested route for which a predetermined test coverage rate has not been obtained, and for this route, test parameters are generated by fuzzy inference and set values Yn as shown in FIG.
and complete the table of test parameters for the independent variable Xn.

In other words, the fuzzy variables between the set value Yn on the right side of the branch conditional expression Sn and the independent variable Xn on the left side are determined based on empirical knowledge, as shown in FIGS. 6 and 7. Membership functions are set for each of Yn and independent variable Xn to generate a fuzzy rule, and the test parameters shown in FIG. 5 are generated based on this fuzzy rule.

In FIG. 2 described above, when the fuzzy rule shown in FIG. 6 is input from the keyboard 18 (step n1
2), the fuzzy editor edits the fuzzy variable table (step n13) and stores it (step n1).
4) This table becomes the source (code) of the fuzzy rule, and the fuzzy rule generator converts this source code into machine language code to be executed (step n15) and edits the file (step 16).

Next, fuzzy inference converted into machine language code is executed on the test parameters, that is, on the branch conditional expression Sn of the given untested route, and the independent variable values are replaced (step n17) and store it (step n18).

Then, the test parameters are loaded into the emulator 21 (step n19) to test the device to be debugged, and the test results are returned to the table (step n20) and the test parameters shown in FIG. The set value Yn and independent variable Xn of the table are sequentially filled in and completed.

Note that test parameters that do not require fuzzy inference are generated by a known conventional method (step n2
1).

FIG. 8 shows a flowchart of test parameter generation and test execution, and corresponds to steps n17 to n21 of the flow of FIG. 2 described above.

That is, test parameters are generated by a well-known generation means (step n31), a test is executed using the test parameters (step n32), and the test results are stored in a table (step n33). Edit the test case table shown in .

Next, it is determined whether the test coverage rate has reached the target (step n34), and if the target has been achieved, the test is terminated, but if it has not been achieved, untested paths are extracted. (Step n35), sets the setting value Yn of the branch conditional expression Sn (Step n36), generates its independent variable Xn by fuzzy reasoning (Step n37), and overwrites the previous variable in FIG. 5 (Step n38). ), a new test parameter table is edited (step n39), and the process returns to step n32. In this way, fuzzy rules are generated from the fuzzy variables between the right-hand side value of the branch conditional expression in the program and the independent variable of the left-hand side value, and the test parameters for testing the untested path of the program are set as the fuzzy rules. When a program is generated by fuzzy inference applying rules and tested, the experience knowledge obtained from depacking and testing similar programs is registered in the form of fuzzy variables, making it easy to use and quantify the experience knowledge. is,
It is possible to generate valid and efficient test parameters.

[0024] Furthermore, when generating test parameters by giving setting values with large margins step by step for a program that has significant non-linearity and unbiased test data is not very effective, the generation process can be made effective; , it is possible to increase the test coverage rate (coverage value) with a small number of tests compared to unbiased test parameters, and as a result, large-scale programs and programs for ultra-high quality systems can be generated effectively at a high rate.

[Brief explanation of the drawing]

FIG. 1 is a system diagram of a program test device of the present invention.

FIG. 2 is a data flow chart of the program test device of the present invention.

FIG. 3 is a flowchart of branch conditional expressions.

FIG. 4 is an explanatory diagram of a test case table.

FIG. 5 is an explanatory diagram of a table of test parameters of setting values and independent variables.

FIG. 6 is an explanatory diagram of a fuzzy variable table between a branch conditional expression and an independent variable.

FIG. 7 is a fuzzy variable explanatory diagram between a branch conditional expression and an independent variable.

FIG. 8 is a flowchart of test parameter generation and test execution.

[Explanation of symbols]

10...Engineering workstation 11...Terminal device 12...Debug execution device 20...Debug target device 21...Emulator

Claims (1)

[Claims] 1. A fuzzy rule is generated from a fuzzy variable between the right-hand side value of a branch conditional expression in a program and an independent variable of the left-hand side value, and test parameters for executing a test on an untested path of the program are set as described above. A program test device that generates programs using fuzzy inference using fuzzy rules.