JP2011159008A - Device and method for testing program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To shorten time required for a program test. <P>SOLUTION: A program test device for testing operation of a changed program when program data are changed includes: a change function extraction part 115 for extracting a part concerned with a function changed in accordance with a change in the program out of test data created by program data before change; a test data creation part 102 for rewriting the part concerned with the changed function out of the test data and using unchanged parts to create test data for the changed program; and a text execution part 103 for executing a test by using the test data created by the test data creation part 102. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a program test apparatus and a program test method.

Program test devices are generally known. The program test apparatus tests only individual modules (components), and tests whether the target module satisfies the required functions and performance.
In recent years, the amount of programs tends to increase as the scale of embedded systems increases. As a means for ensuring quality in program development, it is possible to execute a large amount of tests by unit tests in a program test apparatus for functions.

However, with the increase in the amount of programs, the functions to be tested have increased enormously compared to before, and the scale (number of functions to be tested) is expected to increase in the future.
In the process, the program test equipment takes time to check whether the test data already created for the changed program can be used as it is or whether the test data needs to be corrected. ing. That is, there is a desire to shorten the time (TAT: Turn Around Time) from when the processing result is output until the next request can be accepted.

  Patent Document 1 discloses a technique relating to a retest method and apparatus for facilitating extraction of test data to be retested. FIG. 12 is a system configuration diagram of the program test apparatus disclosed in Patent Document 1.

  The program test device includes a terminal device 1 and a retest device 2. The retest device 2 includes a test data extraction unit 3, a test execution unit 4, a test data grasping unit 5, and a test result verification unit. 6.

  The terminal device 1 inputs the correction module name 15 to the test data extraction unit 3. Here, the correction module name 15 is the name of the module that has been corrected in the program.

The test data related information file 7 stores a correspondence table associating test data with module names. Here, the test data is data input when testing the module.
The test data extraction unit 3 extracts test data related to the correction module name 15 from the test data related information file 7 and outputs the result to the test data extraction file 8.

The test data file 9 stores test data. The test target program file 10 stores a program to be tested.
The test execution unit 4 reads the test data from the test data file 9 and the test target program from the test target program file 10 based on the information in the test data extraction file 8, and executes the test. That is, the test target program file 10 to be tested is tested with the test data extracted from the test data file 9, and the result is output to the verification test result file 12. Here, the verification test result file 12 stores, for example, the name of the test data, the test verification key, and the confirmation content (test result) during the test. The verification key includes, for example, information on a program name to be tested, a module name to be tested, and an execution interruption position.
In addition, the test execution unit 4 reads test coverage information from the test coverage information file 11 and collects the test coverage during the test.

  The test data grasping unit 5 associates the module with the changed test coverage rate collected by the test execution unit 4 with the test data.

In the verification data file 13, for example, a verification key and confirmation contents in the previous test are recorded.
The test result verification unit 6 compares the test result in the verification test result file 12 with the previous test result in the verification data file 13 and outputs the result to the verification result file 14.

  FIG. 13 is a process flow diagram of the test result verification unit 6. The operation of the test result verification unit 6 will be described with reference to FIG.

  First, a verification test result is read from the verification test result file 12 (step 222). Next, the previous test result is read from the verification data file 13 (step 223).

The respective verification keys and confirmation contents are compared (step 224). If they do not match, the verification data in the verification data file 13 and the test result are output to the verification result file 14 (step 225). If yes, the fact that the test results match is output to the verification result file 14 (step 226). Steps 224 to 226 are repeated until all the test results are verified (step 227).
As a result, it is possible to extract from the verification test result file 12 that the verification key and the confirmation content do not match the previous test result. That is, it is possible to automatically extract test data to be retested.

Japanese Patent Laid-Open No. 06-035754

  The technique disclosed in Patent Document 1 has a problem that it takes time to confirm whether or not the test data needs to be corrected. This means that when changing the location of the test data to be retested, the test result that was executed again after changing the program to be tested is compared with the previous test result, and the test results that are different are extracted. Because. In other words, a test must be executed in advance for the confirmation work of the place where the test data needs to be corrected. The program must be tested with the modified test data. As described above, it takes time to execute the program test a plurality of times. In particular, since the amount of programs has increased in recent years, test execution takes time.

  A first aspect of the present invention is a program test apparatus for performing an operation test on a program after change when the program data is changed. Of the test data created by the program data before change, the program is changed. And a modified function extracting unit for extracting a portion related to the function that has been changed, and rewriting the portion related to the changed function in the test data, and diverting the portion that has not been changed to test data for the changed program Is a program test apparatus comprising: a test data creation unit that creates a test data; and a test execution unit that executes a test using the test data created by the test data creation unit.

  According to a second aspect of the present invention, there is provided a method for controlling a program test apparatus for performing an operation test on a program after change when the program data is changed, wherein the program is changed from test data created by the program data before the change. The part related to the function that has been changed is extracted, the part related to the changed function in the test data is rewritten, and the part that has not been changed is used to create test data for the changed program. A program test apparatus control method for executing a test using the created test data.

  As a result, it is necessary to perform preliminary test execution rather than comparing with the test result of the program by extracting the part that needs to be corrected in the test data according to the program change at the function stage. And the time required for the program test is shortened.

  The time required for the program test can be shortened.

1 is a system configuration diagram of a program test apparatus according to a first embodiment; It is test object function data concerning Embodiment 1. FIG. It is a related figure of the test data concerning Embodiment 1. FIG. It is a related figure of the test execution result data concerning Embodiment 1. FIG. It is unchanged function list data concerning Embodiment 1. FIG. It is a related figure of the data for function change detection concerning Embodiment 1. FIG. 3 is an example of creating function change detection data of the program test apparatus according to the first exemplary embodiment; 3 is a control flowchart of an unaltered function list data creation unit of the program test apparatus according to the first exemplary embodiment; It is a figure of the control flowchart of the test data creation part of the program test apparatus concerning Embodiment 1. 3 is a control flowchart of a test execution unit of the program test apparatus according to the first embodiment; FIG. 3 is a system configuration diagram of a program test apparatus according to a second embodiment. It is a system block diagram of the conventional program test apparatus. It is a processing flow of the test result verification part of the conventional program test apparatus.

Embodiment 1
Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 is a system configuration diagram of a program test apparatus.
The program test apparatus 100 includes a change function extraction unit 115, a test data creation unit 102, and a test execution unit 103.
The change function extraction unit 115 extracts a function that has not been changed since the previous test for the source program described in the test target source file 106.
The changed function extraction unit 115 includes an all function information extraction unit 101, a function change detection data creation unit 104, an unchanged function list data creation unit 105, and a function comparison unit 116.

In FIG. 1, a test target source file 106 is a file in which source code to be tested is described. That is, program data.
The language tool 120 is typically a compiler or assembler. For example, the language tool converts a test target source file 106 written in a programming language into a machine language program that can be directly executed by a computer, and creates a test target load module file 107.
The test target load module file 107 is a file output by the language tool 120 based on the test target source file 106.

  The all function information extraction unit 101 reads data from the test target load module file 107 and extracts function information. Here, the test target load module file 107 is a test target and includes a function, and the test target load file 107 is changed from the previous test by changing the test target source file 106. The function information extracted by the all function information extraction unit 101 is typically a function name. The all function information extraction unit 101 outputs the extracted function information as test target function data 108. The all function information extraction unit 101 can extract function information from the test target load module file 107 by using, for example, a debugger.

  The test target function data 108 stores function information output from the all function information extraction unit 101. FIG. 2 is a configuration diagram of the test target function data 108. The test target function data 108 is composed of a plurality of function names 200.

  The function change detection data creation unit 104 creates and outputs function change detection data 112 based on the test target source file 106 to be tested.

The function change detection data 112 stores data output from the function change detection data creation unit 104.
FIG. 6 is a configuration diagram of the function change detection data 112. The function change detection data 112 includes a plurality of function names 700 and detection data 701 associated with the function names 700. The detection data 701 will be described later with reference to FIG.

  The unchanged function list data creation unit 105 creates unchanged function list data based on the function change detection data 112 and the previous test execution result data 113. Unchanged function list data is data of function names of functions that have not been changed. The unmodified function list data creation unit 105 outputs the created data as unmodified function list data 114. The unchanged function list data creation unit 105 will be described later with reference to FIG.

  FIG. 5 is a configuration diagram of the unchanged function list data 114. The unchanged function list data 114 includes a plurality of function names 500 that have not been changed.

  The function comparison unit 116 compares the data stored in the test target function data 108 with the data stored in the unchanged function list data 114, and extracts a function that has been changed.

  The test data creation unit 102 creates test data with the function information extracted by the function comparison unit 116 and the previous test data 109 as inputs. The test data creation unit 102 outputs the created test data as test data 110. The test data creation unit 102 will be described later with reference to FIG.

FIG. 3 is a configuration diagram of the test data 110. The test data 110 includes a plurality of function names 300, change presence / absence information 301, and test items 302. The change presence / absence information 301 is information indicating whether or not the test data 110 has changed from the previous test data 109. The change presence / absence information 301 is associated with the function name 300.
In the test item 302, test items are recorded. The plurality of test items 302 are associated with the function name 300.
The previous test data 109 is test data created in the previous test and has the same configuration as the test data 110. The previous test data 109 stores the test data 110 created during the previous test execution.

  The test execution unit 103 executes a test based on data input from the test target load module file 107, the test data 110, and the function change detection data 112. The test execution unit 103 outputs test execution result data as test execution result data 111.

The test execution result data 111 stores test execution result data output from the test execution unit 103.
FIG. 4 is a configuration diagram of the test execution result data 111. The test execution result data 111 includes a plurality of function names 400, change detection data 401 associated with the function names 400, and determination results 402 associated with the function names 400.
The previous test execution result data 113 has the same configuration as the test execution result data 111. The previous test execution result data 113 stores the test execution result of the test execution result data 111 in the previous test.

  Next, the operation of the program test apparatus according to this embodiment will be described.

First, the program creator creates the test source file 106 while sequentially changing and correcting it.
The test target source file 106 is expanded into the test target load module file 107 by the language tool 120. Then, the test target load module file 107 is read into the all function information extraction unit 101. The all function information extraction unit 101 extracts function names of all functions included in the test target load module file 107 and outputs them as test target function data 108.

  On the other hand, the function change detection data creation unit 104 creates function change detection data 112 from the test source file 106.

  FIG. 7 is an example of creating function change detection data. The operation of the function change detection data creation unit 104 will be described with reference to FIG.

  After the first test execution, when the test source file 106 is modified as the test target function source code 1000 after the function change, the function change detection data creation unit 104 applies the test target function source code 1000 to the test target function source code 1000 after the function change. Performs processing equivalent to compiler preprocessing. That is, the macro character string “NEXT_INDEX” of the test target function source code 1000 is replaced with “4”, the comment character string “/ * comment * /” is deleted, and the intermediate code 1001 is created.

  Next, the function change detection data creation unit 104 creates a function-specific intermediate code 1002 in which the intermediate code 1001 is divided for each block from the first line of the function to the last line of the function. For the function "function", there is one line from the beginning of the line where the string "int function (int arg)" is described to the end of the line where the symbol "}" indicating the end of the function is described. It becomes a block.

Next, the function change detection data creation unit 104 creates detection data 1003 in which blank characters, tabs, and line feed codes are deleted from the function-specific intermediate code 1002. For example, in the example of FIG. 7, the detection data for the function “function” is a single character string “intfunction (intarg) {arg + = 4; returnarg;}”. Here, function is the function name.
This detection data 1003 is taken as detection data 701 associated with the function name 700 in the function change detection data 112.

  The function name 700 and the detection data 701 are input from the function change detection data 112 to the unchanged function list data creation unit 105.

  FIG. 8 is a flowchart showing the operation of the unchanged function list data creation unit 105.

  The unchanged function list data creation unit 105 selects one function name 700 that has not been confirmed in the function change detection data 112 (step S900).

  Next, it is input to the unchanged function list data creation unit 105. The unchanged function list data creation unit 105 checks whether or not the function name 400 that matches the name of the function name 700 selected in step S901 exists in the previous test execution result data 113 (step S901). .

  Here, the case where there is no function name 400 that matches the name of the function name 700 means that a new function has been created. Therefore, in this case, it is determined that there is a function change.

On the other hand, when there is a function name 400 that matches the name of the function name 700, the name of the function that is being detected exists at the time of the previous test. Therefore, in this case, it is confirmed whether the detection data 701 associated with the function name 700 matches the change detection data 401 associated with the function name 400 (step S902).
If the detection data 701 and the change detection data 401 match, the unchanged function list data creation unit 105 determines that the function has not been changed, and outputs the function name 500 to the unchanged function list data 114 ( Step S903). It is assumed that the change detection data 401 is associated with the function name 400 that matches the function name 700. Thereafter, the process proceeds to step S904.
If the detection data 701 and the change detection data 401 do not match, it is determined that there is a function change (NO in step S902), and the flow advances to step S904.

Next, it is determined whether all the function names 700 in the function change detection data 112 have been confirmed (step S904). If the confirmation has been completed (YES in step S904), the process is terminated.
If the confirmation has not been completed (NO in step S904), the process returns to step S900 and is repeated.
As a result, list data of unconverted functions is created and stored in the unmodified function list data 114.

  Next, the function comparison unit 116 compares the data stored in the test target function data 108 with the data stored in the unchanged function list data 114.

  Next, the operation of the test data creation unit 102 will be described.

  FIG. 9 is a control flowchart of the test data creation unit 102.

  First, the test data creation unit 102 selects one function name 200 that does not yet exist in the test data 110 from the test target function data 108 (step S700).

Next, the test data creation unit 102 determines whether or not the same function name as the selected function name 200 exists in the function name 500 in the unmodified function list data 114 based on the result of the comparison performed by the function comparison unit. Confirmation is made (step S701).
If the function name 500 having the same name as the selected function name 200 does not exist (NO in step S701), the function name 300 is created in the test data 110, and the change presence / absence information 301 is set as changed for the function. (Step S702).
If there is a function name 500 having the same name as the selected function name 200, it can be determined that the function has not been changed (YES in step S701), the function name 300 is created in the test data 110, and the function is determined. Sets the related change presence / absence information 301 without change (step S703).

Next, the presence of the matching function name 300 in the previous test data 109 is confirmed, and when it is confirmed that the change presence / absence information 301 is not changed, it is determined that the test item can be diverted (step S704).
If the test item can be diverted (YES in step S704), the test data creation unit 102 copies the test item 302 associated with the function name 300 from the previous test data 109 to the test data 110 (step S705).
If the test item cannot be diverted (NO in step S704), the test data creation unit 102 creates a new test item 302 related to the function name 300 (step S706). The test item 302 may be created by the user of the program test apparatus operating the test data creation unit, or the program test apparatus 100 may have a function of creating the test item 302. The data stored in the test item 302 is an argument of a test target function, a variable referred to by the test target function, or the like.

It is determined whether or not a function for which a test item has not been created remains in the test target function data 108 (step S707), and test items have been created for all the functions in the test target function data 108. (YES in step S707), the process ends.
If there remains a function for which no test item has been created (NO in step S707), the process returns to step S700 and the process is repeated.

Next, the test execution unit 103 outputs the test execution result to the test execution result data 111 based on the test target load module file 107, the test data 110, and the function change detection data 112.
The test execution result data 111 is used as the previous test execution result data 113 at the next test. The test data 110 is used as the previous test data 109 at the next test.

  FIG. 10 is a flowchart showing the operation of the test execution unit 103. A control flow of the test execution unit 103 will be described with reference to FIG.

  First, the test execution unit 103 selects one function name 300 that has not been tested from the test data 110 (step S800).

  Next, the test execution unit 103 selects one unexecuted test item 302 associated with the selected function name 300 (step S801). Next, the test item 302 selected by the test execution unit 103 is executed (step S802).

If all the test items 302 have not been executed for the function name 300, the process returns to step S801 to repeat the process (NO in step S803).
If all test items have been executed for the function name 300 (YES in step S803), the test execution unit 103 includes the function name 400 and the determination result 402 associated with the function name 400 in the test execution result data 111. Create Furthermore, using the detection data 701 input from the function change detection data 112, the change detection data 401 associated with the function name 400 is created and output (step S804). This change detection data is used by the unchanged function list data creation unit 105 to extract a changed function at the next test execution.

It is confirmed that the test execution of all the function names 300 in the test data 110 is finished (step S805), and when the test execution is finished, the process is finished (YES in step S805).
If the test execution has not ended (NO in step S805), the process returns to step S800 to repeat the process.

According to such a program test device of the present embodiment, the following effects can be obtained.
It is possible to confirm in a short time whether the test data needs to be corrected for the corrected test target source file.
By creating function change detection data from the modified test source file and comparing it with the change detection data in the previous test execution result data, it is not necessary to modify the test data by creating the unchanged function list information This is because a simple function can be extracted.

  It is possible to determine whether or not the same function is used regardless of comments or blanks written in the test source file 106. Further, it is possible to use change detection data for determining whether the function is used in the previous test. When determining whether or not the function has been changed, the processing time can be shortened by comparing only the function name first.

Embodiment 2
FIG. 11 is another example of a system configuration diagram of the program test apparatus. The same components as those of the system configuration of the program test apparatus shown in the first embodiment are denoted by the same reference numerals, and description thereof is omitted.

  The system configuration of the program test apparatus shown in FIG. 11 is the same as that of the program test apparatus shown in FIG. It is characterized in that the business data 118 is compared.

Next, the operation will be described.
The function change detection data 112 created by the function change detection data creation unit 104 is stored in the buffer 117. In the next test execution, the previous function change detection data 118 reads the information stored in the buffer 117 and uses this as the previous function change detection data.

  The unchanged function list data creation unit 105 reads the data from the function change detection data 112 and the previous function change detection data 118 and compares them. That is, the unchanged function list data creation unit 105 first compares the function names stored in the function change detection data 112 and the previous function change detection data 118, and the function name currently being tested is Check if it existed during the previous test.

  When the function name exists from the previous test, the unchanged function list data creation unit 105 compares the function change detection data 112 with the detection data stored in the previous function change detection data 118. If the detection data matches, the function name is recorded in the unchanged function list data 114, assuming that the function has not been changed since the previous test.

  If the function name read from the function change detection data 112 cannot be found in the previous function change detection data 118, or the function change detection data 112 and the previous function change detection data 118 have the same function name. If the detection data stored in is different, it is determined that the function has been changed. In this case, the function name is not recorded in the unmodified function list data 114.

  In the second embodiment, the change detection data of the test execution result data 111 is not used. Therefore, the test execution unit 103 does not need to read the detection data 701 from the function change detection data 112. In this case, the test execution unit 103 outputs the function name 400 and the determination result 402 as the test execution result data 111 and does not output the change detection data 401.

  According to such a program test apparatus of the second embodiment, it is not necessary to embed detection data in the test result at the time of test execution.

  Note that the present invention is not limited to the above-described embodiment, and can be changed as appropriate without departing from the spirit of the present invention.

DESCRIPTION OF SYMBOLS 100 Program test apparatus 101 All function information extraction part 102 Test data creation part 103 Test execution part 104 Function change detection data creation part 105 Unchanged function list data creation part 106 Test target source file 107 Test target load module file 108 Test target function Data 109 Test data 110 Test data 111 Test execution result data 112 Function change detection data 113 Test execution result data 114 Unchanged function list data 115 Changed function extraction unit 116 Function comparison unit 117 Buffer 118 Previous function change detection data 120 Language Tool 300 Function name 301 Change presence / absence information 302 Test item 400 Function name 401 Change detection data 402 Judgment result 500 Function name 700 Function name 701 Detection data 1000 Source code 1 01 intermediate code 1002 function by the intermediate code 1003 sensing data

Claims (7)

A program test device that tests an operation of a program after change when program data is changed,
A change function extraction unit that extracts a function name of a function that has been changed according to a program change;
Rewriting the part related to the changed function among the test data, and the test data creating unit for creating the test data for the changed program by diverting the part not changed from the previous test data,
Using the test data created by the test data creation unit, a test execution unit that executes the test of the changed program,
Program test device. The change function extraction unit includes:
An all-function information extraction unit that extracts function names of all functions included in the program data after the change;
A function change detection data creation unit that extracts a function name of the function included in the program data after change and a character string of the function as data for function change detection;
Based on the detection data created by the function change detection data creation unit and the detection data created when testing the program data before the change, the function is changed before and after the change of the program data. An unmodified function list data creation unit that creates list data of functions that have not been performed,
Based on the function information extracted by the all function information extraction unit and the unmodified function list data, the changed function information is extracted.
The program test apparatus according to claim 1. The function change detection data creation unit
Expand the definition of the macro used in the function in the program data, generate the code with the comment removed,
The generated code is divided into function units,
Create a function change detection data by creating a character string with spaces and line breaks removed from the code divided into function units.
The program test apparatus according to claim 2. The test data creation unit
Determine whether there is a function name of the same name in the unchanged function list data created by the unchanged function list data creation unit,
When it is determined that the test target function data has been changed by the determination, a new test item related to the function name is created,
When it is determined that the test target function data target function data is not changed, the previous test data is diverted,
Perform the above-described determination work for all of the test target function data,
The program test apparatus according to claim 2 or claim 3. The unmodified function list data creation unit
Select the function name to be detected from the function change detection data, check whether the function name that matches the function name exists in the test execution result data output by the program data before the change,
If there is a matching function name, check whether the detection data associated with the function name matches the change detection data associated with the function name,
If the detection data matches the change detection data, it is determined that there is no function change, and the function name is recorded as a function name in the unchanged function list data.
The program test apparatus according to any one of claims 2 to 4. The test execution unit
Create a decision result associated with the name of the function that performed the test,
Output the function change detection data and the determination result together as test execution result data,
At the time of the next test, the unchanged function extraction unit extracts an unchanged function by comparing the function change detection data with the test execution result data.
The program test apparatus according to any one of claims 2 to 5. A program test method for executing an operation test of a program after change when program data is changed,
Extract the function name of the function that has been changed with the program change,
Rewrite the part related to the changed function in the test data, and create the test data for the changed program by diverting the part that has not been changed,
A test is executed using the created test data.
Program test method.

Images