JP2023042058A - Information processing apparatus and information processing method - Google Patents

Abstract

To provide a technique capable of suppressing a case where a test target code cannot be corrected appropriately.SOLUTION: An information processing apparatus is provided with a second database for managing malfunctioning candidates in test case execution results in association with one or more pieces of identification information, a third database for managing one or more patterns for correcting a test target code in association with one or more pieces of the identification information, and a modified code generation unit for generating one or more correcting codes for correcting the test target code based on a first database, the second database and the third database.SELECTED DRAWING: Figure 1

Description

The present disclosure relates to an information processing device and an information processing method.

Software programs may contain defects, commonly referred to as "bugs," that prevent them from working as intended. For this reason, code correction devices are often used to correct defects in the code of software programs and the like.

Various techniques have been proposed for such code correction devices. For example, techniques have been proposed for analyzing the characteristics of defects that should be manually resolved from code such as source code and test code, and test execution results. Further, for example, a technique has been proposed for generating corrected code for automatically correcting code by exhaustive search according to a generation algorithm. Further, for example, Patent Literature 1 proposes a technique of creating correction candidates based on an existing code and prioritizing the correction candidates based on the existing code.

Japanese Patent Application Laid-Open No. 2020-126603

However, despite the complexity of the code in real projects, the prior art does not use enough corrective code to fix defects in the code. Therefore, there is a problem that the code under test may not be corrected appropriately.

Therefore, the present disclosure has been made in view of the above-described problems, and aims to provide a technology capable of suppressing the case where the test target code cannot be corrected appropriately.

An information processing apparatus according to the present disclosure includes a first database that manages test case execution results generated by executing a test target code, and a defect candidate in the test case execution result. , a second database that manages one or more pieces of identification information in association with each other; and a third database that manages the one or more pieces of identification information in association with one or more patterns for correcting the code under test. and a correction code generator that generates one or more correction codes for correcting the code under test based on the first database, the second database, and the third database.

According to the present disclosure, since it is possible to generate a plurality of correction codes as necessary, it is possible to suppress cases where the code under test cannot be corrected appropriately.

1 is a block diagram showing a configuration example of a test execution device according to Embodiment 1; FIG. 4 is a flowchart showing the operation of the test execution device according to Embodiment 1; FIG. 5 is a diagram showing an example of a test case execution result database according to the first embodiment; FIG. FIG. 4 is a diagram showing an example of a modified hypothesis database according to Embodiment 1; FIG. FIG. 4 is a diagram showing an example of a correction logic database according to Embodiment 1; FIG. It is a figure which shows an example of the hardware configuration of the test execution apparatus based on another modification. It is a figure which shows an example of the hardware configuration of the test execution apparatus based on another modification.

FIG. 1 is a block diagram showing a configuration example of a test execution device 1 according to the first embodiment. The test execution device 1 tests a test target code, which is a test target code. Codes to be tested are, for example, source code and test code. A test is, for example, a test for checking whether there is a problem in the execution result generated by executing the code under test.

The test execution device 1 of FIG. 1 is connected to a code repository 100 that stores code under test, and is triggered by an operation from a user or an instruction from another system to acquire the code under test from the code repository 100, and , do the test. The test execution device 1 includes a code correction device 2 for correcting the code under test, and is capable of testing while correcting the code under test. In the following description, the information processing device is assumed to be the test execution device 1, but it may be the code correction device 2 as well.

The test execution device 1 includes, in addition to the code correction device 2, a test target code database 101, a test execution unit 104, a test management device 108, and a user interface unit 110 (hereinafter referred to as "UI unit 110"). The code correction device 2 includes a correction test target code database 102 , a code correction section 103 , a test case execution result database 105 , a correction code generation section 106 , a correction logic database 107 and a correction hypothesis database 109 . In the following description, "database" may be abbreviated as "DB".

Next, the constituent elements of the test execution device 1 including the code correction device 2 will be briefly described.

The test execution device 1 acquires the code under test from the code repository 100, and the code under test DB 101 manages the acquired code under test.

The corrected test target code DB 102 manages the test target code corrected by the code correction unit 103 (hereinafter also referred to as "corrected test target code"). The correction test target code DB 102 manages the test target code managed by the test target code DB 101 when the correction test target code does not exist. Hereinafter, the processing related to the test target code will be mainly described first, and then the processing related to the modified test target code will be described.

The test execution unit 104 executes the test target code managed by the modified test target code DB 102 for each test case, and generates test case execution results.

The test case execution result DB 105, which is the first database, manages execution results of test cases generated by executing the test target code in the test execution unit 104. FIG.

The corrected hypothesis DB 109, which is the second database, manages one or more pieces of identification information in association with defect candidates in test case execution results. In the first embodiment, the corrected hypothesis DB 109 also manages candidates for the most probable cause among the causes that cause failures in test case execution results. Hereinafter, the cause with the highest likelihood among the causes of failure in test case execution results may be referred to as a modified hypothesis.

The modification logic DB 107, which is a third database, manages one or more pieces of identification information in association with one or more patterns for modifying the code under test.

Correction code generation unit 106 generates one or more correction codes for correcting the test target code based on test case execution result DB 105 , correction hypothesis DB 109 , and correction logic DB 107 .

The code correction unit 103 corrects the test target code based on the correction code generated by the correction code generation unit 106 .

As described above, the corrected test target code DB 102 manages the test target code corrected by the code correction unit 103, that is, the corrected test target code.

In the first embodiment, the correction test target code managed by the correction test target code DB 102 is subjected to the same processing as the above-described test target code. For example, the test execution unit 104 executes the modified test target code managed in the modified test target code DB 102 for each test case, and generates test case execution results. The test case execution result DB 105 manages execution results of test cases generated by the test execution unit 104 .

That is, in the first embodiment, the execution result generated by executing the corrected test target code in the test execution unit 104 is used as the execution result of the test case generated by executing the test target code. As a result, a series of operations including generation by the correction code generation unit 106, correction by the code correction unit 103, and execution by the test execution unit 104 are repeatedly performed.

The test management device 108 manages the operation of the test execution unit 104 and manages the execution results of the tests generated by the test execution unit 104 . For example, as one such management, the test management device 108 generates information including execution results generated by executing the code under test or the modified code under test in the test execution unit 104 .

The UI unit 110, which is an output unit, outputs information generated by the test management device 108 to the user using at least one of display and sound.

Next, the constituent elements of the test execution device 1 including the code correction device 2 will be described in detail.

Code repository 100 is a tool and database for managing code under test. The code repository 100 is implemented by, for example, a file server and version management tools.

The test target code DB 101 is a database that manages the test target code from the code repository 100 and the corrected test target code from the code correction unit 103 . The code-to-be-tested DB 101 is implemented by, for example, a device that directly stores the code-to-be-tested in a file system, a configuration file such as an archive file, and a device that stores the code in another format such as a relational database.

The corrected test target code DB 102 is a database that manages the test target code or the corrected test target code used in the test execution unit 104 . The modified test target code DB 102 is implemented by, for example, the same device as the test target code DB 101 .

The test execution unit 104 is a device that executes a test target code or a modified test target code and outputs test case execution results. For example, the test execution unit 104 is implemented by a dedicated tool called a continuous integration tool, a batch file that describes the details of processing, and a resident application that executes the batch file.

The test case execution result DB 105 is a database that manages the test case execution results output by the test execution unit 104 , and manages the job execution results that the test execution unit 104 has executed. The execution result of the job includes, for example, pass/fail of the test cases executed by the test execution unit 104, information on the test cases, information on specifications and functions associated with the test cases, corresponding codes and their change history. and/or information.

The test case execution result DB 105 may be operated by the test execution unit 104, may be operated by another device that processes information output by the test execution unit 104, or may be operated by a combination of both. may The test case execution result DB 105 is implemented by, for example, the same device as the test target code DB 101 .

The correction hypothesis DB 109 is a database that manages one or more pieces of identification information in association with defect candidates in test case execution results. The identification information may be an ID or a specific handling method. The corresponding method may be a reference to the correction logic DB 107 or a combination of references to the correction logic DB 107 . The corrected hypothesis DB 109 is implemented by, for example, the same device as the test target code DB 101 .

The correction logic DB 107 manages one or more pieces of identification information in association with one or more patterns for correcting the test target code. The correction logic DB 107 is implemented by, for example, the same device as the test target code DB 101 .

Correction code generation unit 106, when there is a defect in the execution result of the test case, based on the test case execution result DB 105, the correction hypothesis DB 109, and the correction logic DB 107, one or more for correcting the code under test. generate modified code for Note that the correction code generation unit 106 may refer to the test target code or the corrected test target code managed in the correction test target code DB 102 to grasp which line and which description should be corrected. By making such an understanding, it is possible to efficiently generate appropriate correction code. Also, the number of correction codes generated by the correction code generator 106 may be changed according to available time and computational resources. The corrected code may be code corresponding to the difference between the code under test before and after correction, or may be code corresponding to the code under test itself after correction.

The code correction unit 103 acquires the test target code from the test target code DB 101 when the correction code is generated by the correction code generation unit 106, and corrects the test target code based on the correction code. Correction of the code under test is realized, for example, by a replacement method using pattern matching by regular expressions for the code under test, a replacement method using pattern matching for the abstract syntax tree of the code under test, or the like.

The test management device 108 manages the operation of the test execution unit 104 and manages the execution results of the tests generated by the test execution unit 104 . For example, the test management device 108 generates information including execution results generated by executing the code under test or the modified code under test in the test execution unit 104 . Note that the generated information may include not only information actively output by the test execution unit 104 but also information related to the test execution device 1 . The information about the test execution device 1 includes information actively acquired by the test execution unit 104 based on the test case execution result DB 105, and information on correction hypotheses specified by the correction code generation unit 106 as described later. may contain.

The UI unit 110 communicates information generated by the test management device 108 to the user of the test execution device 1 using at least one of display and sound. Note that the output unit is not limited to the UI unit 110, and may be a communication unit or the like that transmits information generated by the test management device 108. FIG.

<Action>
FIG. 2 is a flowchart showing a series of operations including generation by the correction code generation unit 106, correction by the code correction unit 103, and execution by the test execution unit 104 among the operations of the test execution device 1. FIG. It is assumed that before step S1, the test execution unit 104 has already generated test case execution results, and the test case execution result DB 105 has managed the test case execution results.

First, in step S<b>1 , the correction code generation unit 106 identifies defects in the execution results based on the test case execution results managed in the test case execution result DB 105 . Then, based on the identified defect and the correction hypothesis DB 109, the correction code generation unit 106 identifies the correction hypothesis that is the most likely cause of the defect in the execution result of the test case. This will be described below with reference to FIGS. 3 and 4. FIG.

FIG. 3 is a diagram showing an example of the test case execution result DB 105, and more specifically, a diagram showing an example of test case execution results. The test case execution results of the example of FIG.

A test ID 300 is an identifier uniquely attached to a test case. The test target function 301 is the name of the function tested by the test case. The sub-function to be tested 302 is the name of a function included in the function to be tested 301 , for example, the name of a function that is a subordinate concept of the function to be tested 301 . The sub-function under test 302 allows the functionality of the code under test to be structured and managed.

The pass/fail 303 indicates whether the test case was determined to pass or fail. A prediction 304 indicates correct data assumed in the test case. A result 305 indicates the execution result of the test case. For example, when the test ID 300 is "1" or "2", the prediction 304 and the result 305 are different, so the pass/fail 303 is determined to be a failure. On the other hand, when the test ID 300 is "3", the prediction 304 and the result 305 match, so the pass/fail 303 is judged to pass.

A log 306 indicates log information indicating the details of the execution result of the code under test. The log information may be a message as standard output output by the test execution unit 104 .

FIG. 4 is a diagram showing an example of the corrected hypothesis DB 109. As shown in FIG. The modified hypothesis DB 109 in the example of FIG. 4 includes a modified hypothesis ID 400, a name 401, a modified layer 402, a determination condition 403, and a modified logic ID 404. FIG.

The modified hypothesis ID 400 is an identifier uniquely attached to the most probable cause, that is, the modified hypothesis, among the causes of failure in test case execution results. Name 401 is the name of the modified hypothesis. The modified hypothesis DB 109 manages a plurality of modified hypotheses as modified hypothesis candidates.

A modification layer 402 indicates the types of modification hypotheses. For example, if the correction layer 402 is "notation", it indicates that the likelihood of a defect such as a grammatical error or a typo in the code under test is high. For example, if the correction layer 402 is "function", it indicates that the likelihood of the cause of a defect such as an error related to the behavior of the code under test, such as forgetting the initial value of a member variable in the code under test, is high. For example, if the correction layer 402 is "syntax", it indicates that the likelihood of the cause of a defect such as a function error in the code under test is high.

The determination condition 403 is a defect for specifying a correction hypothesis, and the first embodiment shows a format in which the defect is generalized. The correction hypothesis DB 109 manages a plurality of defect formats as defect candidates.

The correction logic ID 404 is an identifier (that is, identification information) indicating a location to be referred to in the correction logic DB 107 when the correction code generation unit 106 creates correction code.

An example of the processing of the correction code generation unit 106 in step S1 will be described below. The correction code generation unit 106 aggregates passed test cases and failed test cases from the test case execution results output by the test execution unit 104 and managed in the test case execution result DB 105 . Correction code generation unit 106 calculates which test target function 301 function is correctly implemented to what degree based on the aggregated result, and based on the calculation result, selects test target function 301 with a relatively large degree of error. Identify. Correction code generator 106 similarly identifies test target sub-functions 302 of the specified test target function 301 as well as test target sub-functions 302 with relatively large error degrees.

The correction code generation unit 106 identifies an error message (for example, information in the log 306 ) of the test case execution result as a defect for the identified test target function 301 and test target sub-function 302 . Note that the correction code generation unit 106 may identify the defect in consideration of the specifications of the test case.

Here, when the corrected code generation unit 106 specifies "user login" and "new user creation by application" as the test target function 301 and the test target sub-function 302, that is, when the test ID 300 of FIG. ” is specified. Assume that the test with the test ID 300 of "2" has an error message "this.userRepository" has no such method "getUser" as in the log 306. FIG. In such a case, the correction code generation unit 106 identifies the error message ""this.userRepository" has no such method "getUser"" as a defect.

Next, correction code generation unit 106 identifies a correction hypothesis based on the identified defect and correction hypothesis DB 109 .

Here, assume that the error message ""this.userRepository" has no such method "getUser"" is identified as a bug. This error message is the determination condition 403 associated with the modified hypothesis ID 400 of "1" among the determination conditions 403 of the modified hypothesis DB 109 in FIG. (.*?)"" format. In this case, the correction code generation unit 106 identifies the name 401 and the correction layer 402 associated with the correction hypothesis ID 400 of "1" as the correction hypothesis.

In step S<b>2 of FIG. 2 , correction code generation unit 106 identifies correction logic for correcting the test target code based on correction logic ID 404 corresponding to the identified correction hypothesis and correction logic DB 107 .

FIG. 5 is a diagram showing an example of the correction logic DB 107. As shown in FIG. The correction logic DB 107 in the example of FIG. 5 includes a correction logic ID 500, a name 501, a correction layer 502, a pattern to be corrected 503, and a pattern 504 after correction.

Correction logic ID 500 is an identifier uniquely attached to correction logic, and corresponds to correction logic ID 404 in FIG. Name 501 is the name of the modification logic. A correction layer 502 indicates the type of correction logic and corresponds to the correction layer 402 in FIG.

The correction target pattern 503 indicates a pattern to which the correction logic is to be applied among the patterns of the test target code. A corrected pattern 504 indicates a pattern after applying the correction logic to the pattern corresponding to the correction target pattern 503 in the test target code.

As described above, in step S<b>2 , the correction code generation unit 106 identifies correction logic for correcting the test target code based on the correction logic ID 404 corresponding to the identified correction hypothesis and the correction logic DB 107 .

Here, as described above, it is assumed that the name 401 and the correction layer 402 associated with "1" of the correction hypothesis ID 400 in FIG. 4 are specified as the correction hypothesis. In this case, since the correction logic IDs 404 corresponding to the correction hypotheses are "5" and "6", the correction code generation unit 106 selects the correction logic IDs 500 of "5" and "6" in the correction logic DB 107 of FIG. Identify two modification logics where

In step S3 of FIG. 2, the correction code generation unit 106 identifies the pattern to be corrected and the content of correction based on the identified correction logic. For example, when two correction logics whose correction logic IDs 500 are "5" and "6" are identified as described above, the correction code generation unit 106 generates the correction target pattern 503 and the corrected pattern 503 for each of the two correction logics. identifies the pattern 504 of .

In step S4 of FIG. 2, the correction code generation unit 106 generates a correction code based on the specified correction target pattern and correction content. For example, when the pattern to be corrected 503 and the pattern after correction 504 are specified for each of the two correction logics, the correction code generation unit 106 generates two correction codes. Thus, when a plurality of correction target patterns and correction details are specified in step S3, the correction code generation unit 106 generates a plurality of correction codes.

In step S<b>5 , the code correction unit 103 corrects the test target code based on the correction code generated by the correction code generation unit 106 . If a plurality of correction codes have been generated in step S4, the code correction unit 103 corrects the test target code based on any one of the plurality of correction codes.

In step S6, the test execution unit 104 executes the modified test target code to generate test case execution results.

In step S7, the test execution unit 104 determines whether or not the execution result of the test case is passed. If the execution result of the test case is determined to pass, the operation of FIG. 2 ends. If the execution result of the test case is determined to be a failure, the process proceeds to step S8.

In step S8, the correction code generator 106 determines whether or not the processes of steps S5 and S6 have been performed for all of the correction codes generated by the correction code generator 106. FIG. If it is determined that all correction codes have been processed, the process proceeds to step S9. If it is determined that all correction codes have not been processed, the process proceeds to step S5, and the unprocessed correction codes are processed in steps S5 and S6.

In step S9, the correction code generation unit 106 determines whether or not the correction hypothesis identified in step S1 correctly reflects the cause of the defect, based on the execution result of the test target code.

The modified code generation unit 106 may make this determination based on at least one of the number of passed or failed test cases and the dependency relationship for each test case. For example, it is assumed that test case execution results are generated for the function "to be able to execute the function without error" and the function "to give the output specified by the function". Since the former function is a basic function for the latter function, when the test of the latter function is passed but the test of the former function is unsuccessful, the correction code generation unit 106 It may be determined that the identified correction hypothesis does not correctly reflect the cause of the defect.

If it is determined in step S9 that the modified hypothesis correctly reflects the cause of the problem, that is, if it is determined that there is no need to change the modified hypothesis, the process proceeds to step S10. If it is determined in step S9 that the modified hypothesis does not correctly reflect the cause of the defect, that is, if it is determined that the modified hypothesis needs to be changed, the process proceeds to step S1, and another modified hypothesis is used. identify.

In step S10, the modification code generation unit 106 generates a new modification code without changing the modification hypothesis.

The correction code generation unit 106 may generate a new correction code that is more complicated than the previously generated correction code. Moreover, the correction code generation unit 106 may generate a new correction code based on the previously generated correction code. For example, if the correction code generated last time is a correction code that adds the line "if (!this.member) { return }", the correction code generation unit 106 generates "if ( !this.member.name) {return;}" can be modified code.

If a plurality of correction codes have been generated, the correction code generation unit 106 selects one correction code from among the plurality of correction codes according to a certain scale, and creates a new correction code based on the one correction code. Generate modified code. In addition, the correction code generation unit 106 selects one of the plurality of correction codes based on at least one of the number of passed test cases, the number of failed test cases due to correction, and the type of parent function. , a modification code to be used for generating a new modification code may be selected. Further, the correction code generation unit 106 may combine a plurality of correction codes to generate a new correction code. Further, the correction code generation unit 106 may perform machine learning on the correction code and generate a new correction code based on the learning result. After step S10, the process proceeds to step S5.

<Summary of Embodiment 1>
As a related technique related to the test execution device 1 according to the first embodiment, a technique using the modification logic according to the first embodiment as a schema can be considered. However, since codes required in actual development are complicated, even if one correction code is generated for a defect, the code under test may not be corrected appropriately. Also, by checking log messages and failed test cases, guessing the cause, and repeating corrections, it is possible to generate complex and correct correction code while limiting the types of correction code. However, it requires human effort and time for people to get used to it.

On the other hand, in the first embodiment, the correction code generation unit 106 generates one or more code for correcting the test target code based on the test case execution result DB 105, the correction hypothesis DB 109, and the correction logic DB 107. generate modified code for According to such a configuration, it is possible to automatically generate a plurality of complicated and correct correction codes as necessary, so it is possible to suppress cases where the code under test cannot be corrected appropriately. Also, by appropriately setting the correction logic ID in the correction hypothesis DB 109, generation of unnecessary correction code can be suppressed.

Further, in the first embodiment, the code correction unit 103 corrects the test target code based on the correction code generated by the correction code generation unit 106, so that defects in the test target code can be automatically corrected. .

In addition, in the first embodiment, the UI unit 110 outputs information including the execution result generated by executing the modified test target code in the test execution unit 104. Therefore, for example, the user can check the information. can.

In addition, in the first embodiment, since a series of operations including generation by the correction code generation unit 106, correction by the code correction unit 103, and execution by the test execution unit 104 are repeated, the code under test cannot be corrected appropriately. The case can be further suppressed.

<Modification>
The operation of the test execution device 1 is not limited to the above. For example, in the above description, one correction hypothesis is processed until it is determined that the correction hypothesis does not correctly reflect the cause of the defect in step S9 of FIG. processed accordingly. However, the process is not limited to this, and a plurality of correction hypotheses may be processed in parallel. For example, when the upper limit of the number of correction codes that can be generated is 100, 70 of them may be assigned to correction codes based on one correction hypothesis, and 30 of them may be assigned to correction codes based on another correction hypothesis.

Further, in the above description, the correction code generation unit 106 identifies correction hypotheses based on the identified defect and the correction hypothesis DB 109, and identifies one or more correction logic IDs 404 based on the identified correction hypotheses. . However, the modification code generator 106 directly identifies one or more modification logic IDs 404 without identifying modification hypotheses based on the identified defect and the modification hypothesis DB 109. You may

<Other Modifications>
The correction code generator 106 in FIG. 1 described above is implemented by the processing circuit 81 shown in FIG. That is, the processing circuit 81 includes a correction code generation unit 106 that generates one or more correction codes for correcting the code under test based on the test case execution result DB 105, the correction hypothesis DB 109, and the correction logic DB 107. Prepare. Dedicated hardware may be applied to the processing circuit 81, or a processor that executes a program stored in a memory may be applied. Processors include, for example, central processing units, processing units, arithmetic units, microprocessors, microcomputers, and DSPs (Digital Signal Processors).

When the processing circuit 81 is dedicated hardware, the processing circuit 81 may be, for example, a single circuit, a composite circuit, a programmed processor, a parallel programmed processor, an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or a combination of these. The correction code generation unit 106 may be implemented by a circuit in which processing circuits are distributed, or may be implemented by a single processing circuit that integrates the functions of each unit.

When the processing circuit 81 is a processor, the function of the correction code generator 106 is realized by combining with software or the like. Software and the like correspond to, for example, software, firmware, or software and firmware. Software or the like is written as a program and stored in memory. As shown in FIG. 7, a processor 82 applied to a processing circuit 81 reads out and executes a program stored in a memory 83 to realize functions of each section. That is, when the test execution device 1 is executed by the processing circuit 81, based on the test case execution result DB 105, the correction hypothesis DB 109, and the correction logic DB 107, one or more A memory 83 is provided for storing the program that will result in the step of generating the modified code. In other words, it can be said that this program causes a computer to execute the procedures and methods of the modification code generation unit 106 . Here, the memory 83 is, for example, a non-volatile or Volatile semiconductor memory, HDD (Hard Disk Drive), magnetic disk, flexible disk, optical disk, compact disk, mini disk, DVD (Digital Versatile Disc), drive devices thereof, etc., or any storage medium that will be used in the future There may be.

The configuration in which the functions of the correction code generation unit 106 are realized by either hardware or software has been described above. However, the configuration is not limited to this, and a configuration in which part of the correction code generation unit 106 is realized by dedicated hardware and another part is realized by software or the like may be employed. For example, the processing circuit 81 as dedicated hardware and an interface implement some functions, and the processing circuit 81 as the processor 82 reads and executes the program stored in the memory 83 for other functions. It is possible to implement functions.

As described above, the processing circuit 81 can implement each of the functions described above using hardware, software, etc., or a combination thereof. Note that the above also applies to the code correction unit 103 and the test execution unit 104 as well.

Moreover, each function or each component of the test execution device 1 described above may be distributed to each device that constructs the system, or may be centrally disposed in any one of the devices.

In addition, it is possible to modify or omit the embodiments as appropriate.

1 test execution device, 103 code correction unit, 104 test execution unit, 105 test case execution result DB, 106 correction code generation unit, 107 correction logic DB, 109 correction hypothesis DB, 110 UI unit.

Claims (6)

a first database that manages execution results of test cases generated by executing the code under test, which is the code under test;
a second database that associates and manages one or more pieces of identification information with defect candidates in the execution results of the test cases;
a third database that manages the one or more pieces of identification information in association with one or more patterns for correcting the code under test;
An information processing device, comprising: a correction code generation unit that generates one or more correction codes for correcting the test target code based on the first database, the second database, and the third database. . The information processing device according to claim 1,
The information processing apparatus further comprising a code correction unit that corrects the test target code based on the correction code generated by the correction code generation unit. The information processing device according to claim 2,
a test execution device that executes the modified test target code, which is the test target code modified by the code modification unit;
An information processing apparatus, further comprising an output unit that outputs information including an execution result generated by executing the modified test target code with the test execution apparatus. The information processing device according to claim 3,
An information processing device, wherein an execution result generated by executing the modified test target code by the test execution device is used as an execution result of the test case. The information processing device according to claim 4,
An information processing device in which a series of operations including generation by the correction code generation unit, correction by the code correction unit, and execution by the test execution device are repeatedly performed. managing the execution results of the test cases generated by executing the code under test, which is the code under test, in the first database;
in a second database, one or more pieces of identification information are associated with the defect candidates in the execution results of the test cases, and managed;
in a third database, managing the one or more pieces of identification information in association with one or more patterns for correcting the code under test;
An information processing method, wherein one or more correction codes for correcting the code under test are generated based on the first database, the second database, and the third database.

Images