JP6365276B2 - Program, information processing apparatus and information processing method - Google Patents

Description

  The present invention relates to a program, an information processing apparatus, and an information processing method.

  Conventionally, a technique for performing functional simulation and verification of a computer program by inserting a syntactic mutant into one of source code modules constituting the program has been disclosed (see, for example, Patent Documents 1 and 2).

JP 2000-222244 A Japanese Patent Laid-Open No. 08-044590

  However, the conventional technique has a problem that it is impossible to estimate a missing part of a corrected program.

  In one aspect, an object is to provide a program or the like that can estimate a missing part of a modified program.

  In one proposal, the program obtains a first test result by executing a plurality of tests on a modified program obtained by modifying the original program on a computer, and for a mutant generated based on the original program, A code that obtains a second test result by executing the plurality of tests, and that estimates a lack of the correction program based on a correlation between the failed test and the first test result among the second test results Is executed.

  In one aspect, it is possible to estimate missing portions of the modified program.

It is a block diagram which shows the hardware group of information processing apparatus. It is explanatory drawing which shows the memory content of test suite DB. It is explanatory drawing which shows the record layout of correction program execution result DB. It is explanatory drawing which shows the memory content of mutant operator DB. It is explanatory drawing which shows the record layout of execution result DB. It is a flowchart which shows the procedure of a mutant production | generation process. It is a flowchart which shows the memory processing procedure of a test result. It is a flowchart which shows the estimation process of a missing code. It is a functional block diagram which shows operation | movement of the computer of the form mentioned above. FIG. 6 is a block diagram illustrating a hardware group of a computer according to a second embodiment.

Embodiment 1
Hereinafter, embodiments will be described with reference to the drawings. FIG. 1 is a block diagram illustrating a hardware group of the information processing apparatus 1. The information processing apparatus 1 is a server computer, a personal computer, a mobile phone, a smartphone, a game machine, a PDA (Personal Digital Assistant), or the like. Hereinafter, the information processing apparatus 1 will be described as being replaced with the computer 1. The computer 1 includes a CPU (Central Processing Unit) 11 as a control unit, a RAM (Random Access Memory) 12, an input unit 13, a display unit 14, a storage unit 15, a communication unit 16, and the like.

  The CPU 11 is connected to each part of the hardware via the bus 17. The CPU 11 controls each part of the hardware according to the control program 15P stored in the storage unit 15. The RAM 12 is, for example, (Static RAM), DRAM (Dynamic RAM), flash memory, or the like. The RAM 12 also functions as a storage unit, and temporarily stores various data generated when the CPU 11 executes various programs.

  The input unit 13 is an input device such as a mouse or a keyboard, a mouse or a touch panel, and outputs received operation information to the CPU 11. The display unit 14 is a liquid crystal display, an organic EL (electroluminescence) display, or the like, and displays various information according to instructions from the CPU 11. The communication unit 16 is a communication module, and transmits / receives information to / from other computers (not shown) via a communication network N such as the Internet.

  The storage unit 15 is a hard disk or a large-capacity memory, and includes a control program 15P, a test suite database (hereinafter referred to as DB) 151, a correction program execution result DB 152, and a mutant operator DB 153. The storage unit 15 stores a mutant DB 154, an execution result DB 155, and the like. In the embodiment, the example in which the test suite DB 151 and the like are stored in the storage unit 15 is described, but the present invention is not limited to this. In addition to being stored in the RAM 12, it may be stored in another DB server (not shown).

  FIG. 2 is an explanatory diagram showing the contents stored in the test suite DB 151. The test suite DB 151 stores a plurality of tests executed on the program. In the present embodiment, an example in which tests from Test 1 to Test 50 are used will be described. However, the numerical value is an example, and the present invention is not limited to this.

  FIG. 3 is an explanatory diagram showing a record layout of the correction program execution result DB 152. In association with each test, the execution result is stored as success or failure. In the example of FIG. 3, test 1 and test 2 succeeded, but test 3 failed. The CPU 11 reads the original program from the storage unit 15 and displays it on the display unit 14. The user appropriately modifies the original program through the input unit 13. The CPU 11 receives the correction of the program from the input unit 13 and stores the received correction program after the correction in the storage unit 15.

  The CPU 11 reads the modification program from the storage unit 15, executes the tests 1 to 50 stored in the test suite DB 151, and stores the execution result of each test in the modification program execution result DB 152.

  FIG. 4 is an explanatory diagram showing the contents stored in the mutant operator DB 153. The mutant operator DB 153 stores a plurality of mutant operators for generating a mutant that is a program including an artificial error. For example, the mutant operator “<→>” rewrites “>” in which the magnitude relationship is reversed when “<” exists in the code of the original program. The CPU 11 generates a plurality of mutants for the code by rewriting a specific code of the original program. The CPU 11 stores the generated mutant in the mutant DB 154.

  FIG. 5 is an explanatory diagram showing a record layout of the execution result DB 155. The execution result DB 155 includes an original program field, a mutant operator field, a row field, a test field, a success number field, a failure number field, a risk value field, a risk average value field, and the like. In the original program field, the code of the original program before correction is stored. The contents stored in the execution result DB 155 are not limited to the example shown in FIG. Other storage forms may be used as long as the relationship between data is maintained.

  In the mutant operator field, a plurality of mutant operators for rewriting the code of the original program is stored. In the line field, a line number for specifying the line of the code is stored in association with the code. In the test field, the result of testing the mutant for each test is stored. For example, the test result for the mutant using the mutant operator indicated by M2 stores “1” indicating that the test 1 has failed and “1” indicating that the test 2 has also failed.

  Further, for example, the test result for the mutant using the mutant operator indicated by M46 stores “0” indicating that the test 1 has succeeded and “1” indicating that the test 3 has failed. In the lower part of FIG. 5, the execution result of the correction program is described corresponding to each test for easy explanation. For example, it can be understood that test 1 for the modification program is “successful” and test 3 for the modification program is “failed”. Note that the number of mutants for one line of code is an example and is not particularly limited.

  In the success number field, the success number is stored in association with the code and the mutant operator. Specifically, the CPU 11 refers to the correction program execution result DB 152 and the execution result DB 155, and stores the number of tests for the original program mutant that have failed and the corresponding test for the correction program succeeded. In the failure number field, the number of failures is stored in association with the code and the mutant operator. Specifically, the CPU 11 refers to the correction program execution result DB 152 and the execution result DB 155, and stores the number of tests for the original program mutant that have failed and the corresponding test for the correction program failed.

  In the example of FIG. 5, the mutant operator M2 is used for the row 11, and the result of the test 1 is “1”, which is unsuccessful. The corresponding test 1 fix results are successful. In this case, the CPU 11 increments the number of successes in the execution result DB 155. The result of test 2 is “1”, which is unsuccessful. The corresponding test 1 fix result is successful. Also in this case, the CPU 11 increments the success number. The result of test 3 is “1”, which is unsuccessful. The corresponding test 1 fix results are unsuccessful. In this case, the CPU 11 increments the number of failures. As a result of performing the same processing for each test, among all the tests 50, the number of successes is 40 and the number of failures is stored as 10.

  Next, attention is paid to the mutant operator M46 in the 17th row. For tests 1 and 2, the result is 0 indicating success, so the number of successes and the number of failures are not executed. For test 3, the result is 1 indicating failure, and the result of test 3 of the correction program is also failure, so the CPU 11 increments the number of failures by 1. The CPU 11 performs the same processing up to the test 50. In the example of FIG. 5, when the mutant operator M46 is used, the number of successes is 0 and the number of failures is 10.

  Subsequently, the CPU 11 obtains a total value of the number of failures of each mutant and calculates an average number of failures by dividing by the total number of mutants. In the present embodiment, the average number of failures is used as a parameter for obtaining a risk value described later. In addition to the average failure count, a value stored in advance in the storage unit 15 may be used as a parameter.

  The CPU 11 determines whether or not the number of successes of each mutant is greater than the sum of the number of failures plus the average number of failures (hereinafter referred to as an added value). If the CPU 11 determines that it is not large, it stores risk 0 in the risk value field. When the CPU 11 determines that the value is large, it stores the number of failures of the mutant in the risk value field. In the example of FIG. 5, the risk value of the mutant using the mutant operator M42 is stored as 10.

  The average risk value of each code is stored in the risk average value field. CPU11 calculates | requires the total value of the risk value of all the mutants for every line. The CPU 11 calculates the risk average value of each code by dividing the total value by the total number of mutants in the row. In the example of FIG. 5, the risk average value of the code of the 11th line is 0, and the risk average value of the code of the 17th line is 4.29. The CPU 11 estimates that the code having the highest risk average value is a missing code. The CPU 11 outputs the code that estimates the loss to the display unit 14. Note that the estimated code may be output to another computer via the communication unit 16.

  In the above hardware group, various software processes will be described with reference to flowcharts. FIG. 6 is a flowchart showing the procedure of the mutant generation process. CPU11 reads a correction program from the memory | storage part 15 (step S61). The CPU 11 reads a plurality of tests from the test suite DB 151 (step S62). The CPU 11 performs all tests on the correction program and stores the test result in the correction program execution result DB 152 (step S63). As illustrated in FIG. 3, the CPU 11 stores information indicating success or failure in association with the test in the correction program execution result DB 152.

  CPU11 reads the original program before correction from the memory | storage part 15 (step S64). CPU11 extracts the code | cord | chord which applies a mutant operator (step S65). In the example of FIG. 5, codes such as the 11th and 17th lines are extracted as the codes to be applied. The CPU 11 reads a plurality of mutant operators from the mutant operator DB 153 (step S66). The CPU 11 stores the code, line, and mutant operator of the original program in the execution result DB 155. The CPU 11 causes a mutant operator to act on the original program and generates a mutant (step S67).

  The CPU 11 stores the generated mutant in the mutant DB 154 (step S68). The CPU 11 determines whether or not the processing for all the mutant operators has been completed (step S69). If the CPU 11 determines that the process for all the mutant operators has not been completed (NO in step S69), the process returns to step S67. The CPU 11 performs the process of step S67 using an unprocessed mutant operator. Thereby, a mutant using all the mutant operators is generated.

  If the CPU 11 determines that the process for all the mutant operators has been completed (YES in step S69), the process proceeds to step S610. The CPU 11 determines whether or not the processing has been completed for all the codes to be applied (step S610). If the CPU 11 determines that the processing for all codes has not been completed (NO in step S610), the process returns to step S66. The CPU 11 performs the processing from step S66 on the unprocessed code. As a result, a plurality of mutants are generated for each chord. If the CPU 11 determines that the processing for all the codes has been completed (YES in step S610), the series of processing ends.

  FIG. 7 is a flowchart showing a test result storing process. The CPU 11 reads the original program mutant from the mutant DB 154 (step S71). The CPU 11 reads a test from the test suite DB 151 (step S72). The CPU 11 performs a test on the mutant, and stores the test result in the execution result DB 155 in association with the mutant and the test (step S73). The CPU 11 refers to the modification program execution result DB 152 to determine whether or not the mutant test result is unsuccessful and the corresponding test result of the modification program is successful (step S74).

  If the CPU 11 determines that the mutant test result is unsuccessful and the corresponding test result of the correction program is successful (YES in step S74), the CPU 11 causes the process to proceed to step S75. The CPU 11 increments the number of successful mutants in the execution result DB 155 (step S75). After that, the CPU 11 shifts the process to step S78. If the CPU 11 determines that the mutant test result is unsuccessful and the corresponding test result of the correction program is not successful (NO in step S74), the process proceeds to step S76.

  If the CPU 11 determines that the mutant test result is unsuccessful and the corresponding test result of the correction program is unsuccessful (YES in step S76), the CPU 11 proceeds to step S77. The CPU 11 increments the number of failure of the mutant in the execution result DB 155 (step S77). After that, the CPU 11 shifts the process to step S78. If the CPU 11 determines that the mutant test result is unsuccessful and the corresponding test result of the correction program is not unsuccessful (NO in step S76), the process proceeds to step S78. In the present embodiment, the process of step S74 is performed before step S76, but the process of step S76 may be performed first.

  The CPU 11 determines whether or not the processing has been completed for all tests (step S78). If the CPU 11 determines that the process has not been completed for all tests (NO in step S78), the process returns to step S72. By repeating the above processing, each test result, the number of successes and the number of failures for the mutant are stored.

  If the CPU 11 determines that the process has been completed for all tests (YES in step S78), the process proceeds to step S79. The CPU 11 determines whether or not the processing for all the mutants has been completed (step S79). If the CPU 11 determines that the process for all the mutants has not been completed (NO in step S79), the process returns to step S71. As a result, test results, success numbers, and failure numbers for all mutants are stored. If the CPU 11 determines that the process for all the mutants has been completed (YES in step S79), the process ends.

  FIG. 8 is a flowchart showing a missing code estimation process. The CPU 11 refers to the execution result DB 155 and calculates the total value of the number of failures of all mutants (step S81). The CPU 11 calculates the average number of failures by dividing the total value by the number of all mutants (step S82). The CPU 11 determines whether or not the number of successes of each mutant is greater than an addition value obtained by adding the average number of failures to the number of failures (step S83). If the CPU 11 determines that the number of successes is greater than the value obtained by adding the average number of failures to the number of failures (YES in step S83), the process proceeds to step S84.

  The CPU 11 stores the risk value 0 in the execution result DB 155 in association with the mutant (step S84). After that, the CPU 11 shifts the process to step S86. If the CPU 11 determines that the number of successes is not greater than the value obtained by adding the average number of failures to the number of failures (NO in step S83), the process proceeds to step S85. The CPU 11 stores the number of failures in the mutant as a risk value in association with the mutant in the execution result DB 155 (step S85). The CPU 11 determines whether or not the processing for all the mutants has been completed (step S86).

  CPU11 returns a process to step S83, when the process with respect to all the mutants is not completed (it is NO at step S86). CPU11 performs the process after step S83 with respect to an unprocessed mutant. As a result, risk values for all mutants are calculated. If the CPU 11 determines that the process for all the mutants has been completed (YES in step S86), the process proceeds to step S87.

  CPU11 calculates a risk average value from the average of the risk value for every code (step S87). Specifically, the CPU 11 calculates a risk average value by obtaining a total value of the risk values of the mutants in the same code and dividing by the total number of mutants in the same code. CPU11 outputs the code | cord | chord which has the largest risk average value to the display part 14 as a code | cord | chord with which a defect | deletion is estimated (step S88).

  In addition, although the example which outputs the code | cord | chord with the largest risk average value was shown for the code | symbol with which a loss is estimated, it is not restricted to this. You may output the code | cord | chord of the high-order several lines with a large average risk value as a code | symbol from which a defect | deletion is estimated. Further, instead of the risk average value, the code having the largest total value or the code of the top several lines having the largest total value may be output as the code for which the loss is estimated. As a result, it is possible to estimate the missing part of the modified program. Moreover, it is possible to accurately estimate the missing portion of the code by the correlation between the correction program and the mutant. Further, the accuracy can be improved by using the average number of failures as a parameter.

Embodiment 2
FIG. 9 is a functional block diagram showing the operation of the computer 1 of the above-described form. When the CPU 11 executes the control program 15P, the computer 1 operates as follows. The 1st acquisition part 91 acquires a 1st test result by performing a plurality of tests with respect to a correction program which corrected an original program. The second acquisition unit 92 acquires the second test result by executing the plurality of tests on the mutant generated based on the original program. The output unit 93 outputs a code in which a defect of the correction program is estimated based on the correlation between the failed test of the second test results and the first test result.

  FIG. 10 is a block diagram illustrating a hardware group of the computer 1 according to the second embodiment. A program for operating the computer 1 reads a portable recording medium 1A such as a CD-ROM, a DVD (Digital Versatile Disc) disk, a memory card, or a USB (Universal Serial Bus) memory into a reading unit 10A such as a disk drive. It may be stored in the storage unit 15. Further, a semiconductor memory 1B such as a flash memory storing the program may be mounted in the computer 1. Further, the program can be downloaded from another server computer (not shown) connected via a communication network N such as the Internet. The contents will be described below.

  The computer 1 shown in FIG. 10 reads the program for executing the above-described various software processes from the portable recording medium 1A or the semiconductor memory 1B or downloads it from another server computer (not shown) via the communication network N. To do. The program is installed as the control program 15P, loaded into the RAM 12, and executed. Thereby, it functions as the computer 1 described above.

  The second embodiment is as described above, and the others are the same as those of the first to fifth embodiments. Therefore, the corresponding parts are denoted by the same reference numerals and detailed description thereof is omitted.

  With respect to the embodiments including the first and second embodiments, the following additional notes are disclosed.

(Appendix 1)
On the computer,
The first test result is obtained by executing a plurality of tests on the modified program obtained by modifying the original program,
A second test result is obtained by executing the plurality of tests on the mutant generated based on the original program,
A program for executing a process of outputting a code in which a deficiency of the correction program is estimated based on a correlation between a failed test among the second test results and the first test result.
(Appendix 2)
Count the number of successes that failed the test against the mutant and succeeded in the test against the modification program,
Count the number of failures that failed the test against the mutant and failed the test against the modification program,
The program according to appendix 1, wherein a code that estimates a deficiency is output based on the magnitude relationship between the number of successes and the number of failures.
(Appendix 3)
A plurality of mutants are generated for each code of the program,
The program according to appendix 2, wherein the second test result is obtained by executing the plurality of tests for each mutant.
(Appendix 4)
Calculate the average number of failures based on the number of failures of each mutant counted,
The program according to claim 3, wherein a code that estimates a deficiency is output based on a magnitude relationship between the counted number of successes of each mutant and the sum of the number of failures plus the average number of failures.
(Appendix 5)
If the sum is greater than the success number, extract the failure number;
Calculate the average number of failures extracted for each code,
The program according to appendix 4, which outputs a code for which a loss is estimated based on the calculated average value.
(Appendix 6)
A first acquisition unit that acquires a first test result by executing a plurality of tests on a correction program obtained by correcting the original program;
A second acquisition unit that acquires a second test result by executing the plurality of tests on the mutant generated based on the original program;
An information processing apparatus comprising: an output unit that outputs a code for which a deficiency of the correction program is estimated based on a correlation between a failed test of the second test results and the first test result.
(Appendix 7)
The first test result is obtained by executing a plurality of tests on the modified program obtained by modifying the original program,
A second test result is obtained by executing the plurality of tests on the mutant generated based on the original program,
An information processing method using a computer that outputs a code in which a deficiency of the correction program is estimated based on a correlation between a failed test of the second test results and the first test result.

DESCRIPTION OF SYMBOLS 1 Computer 1A Portable recording medium 1B Semiconductor memory 10A Reading part 11 CPU
12 RAM
13 Input unit 14 Display unit 15 Storage unit 15P Control program 16 Communication unit 151 Test suite DB
152 Correction program execution result DB
153 Mutant Operator DB
154 Mutant DB
155 Execution result DB
91 first acquisition unit 92 second acquisition unit 93 output unit N communication network

Claims (5)

On the computer,
The first test result is obtained by executing a plurality of tests on the modified program obtained by modifying the original program,
A second test result is obtained by executing the plurality of tests on the mutant generated based on the original program,
A program for executing a process of outputting a code in which a deficiency of the correction program is estimated based on a correlation between a failed test among the second test results and the first test result. Count the number of successes that failed the test against the mutant and succeeded in the test against the modification program,
Count the number of failures that failed the test against the mutant and failed the test against the modification program,
The program according to claim 1, wherein a code in which a deficiency is estimated is output based on a magnitude relationship between the success number and the failure number. A plurality of mutants are generated for each code of the program,
The program according to claim 2, wherein the second test result is obtained by executing the plurality of tests for each mutant. A first acquisition unit that acquires a first test result by executing a plurality of tests on a correction program obtained by correcting the original program;
A second acquisition unit that acquires a second test result by executing the plurality of tests on the mutant generated based on the original program;
An information processing apparatus comprising: an output unit that outputs a code for which a deficiency of the correction program is estimated based on a correlation between a failed test of the second test results and the first test result. The first test result is obtained by executing a plurality of tests on the modified program obtained by modifying the original program,
A second test result is obtained by executing the plurality of tests on the mutant generated based on the original program,
An information processing method using a computer that outputs a code in which a deficiency of the correction program is estimated based on a correlation between a failed test of the second test results and the first test result.

Images