JP6903533B2 - Debug support device, debug support program - Google Patents

Description

The present invention relates to a debug support device and a debug support program used in software development and the like.

In a version control system, in the case of a debug that passes the test in one version A and then fails the test in another version B, by binary search for the pass / fail test for each version between AB. , There is a debug support function to identify the commit that is the change point from passing the exam to failing the exam.

Japanese Unexamined Patent Publication No. 6-355754

However, in the conventional debug support function, the degradation point is specified in units of commits, so if the difference included in the commit is large, the difference will be based on the skill, knowledge, and rules of thumb of the person in charge of development. It was necessary to analyze the factors that changed the pass / fail of the test and identify the location of the degradation factor.

Especially when merging between branches, the source code difference included in the commit is likely to be large and degradation is likely to occur, so it is necessary for the developer to analyze the degradation factor and identify the relevant part of the source code. There were many things.

In addition, when expanding the test data file, latent defects in the program are likely to appear by adding corner cases that were not considered in the data file before expansion, but it is tested which additional data the latent defects appear in. Since it is difficult to clarify completely in some cases, it was necessary for developers to analyze potential defects to identify the data.

Therefore, there is a problem that it is difficult to identify the cause of the test failure of the source code and the data file unless the person in charge of development has skills, knowledge, and empirical rules, and it takes man-hours.

The present invention has been made to solve the above problems, and provides a debug support device and a debug support program that can efficiently identify the test failure factor part of the source code or the data file. With the goal.

According to the embodiment, the debug support device has a small difference list initialization unit and a small difference list search unit. The small difference list initialization unit is the first data table of the first test pass source code and data file stored in the first storage unit, and the test failure source code and data file stored in the second storage unit. 2 Extract the difference from the data table, create a subdivided list of small differences, and store it in the third storage unit. The small difference list search unit repeatedly performs the test by applying the combination of the small differences included in the list to the source code and the data file that passed the first test, and selects the combination of the small differences that fails the test. Search and output.

The block diagram which shows the structure of the debug support apparatus in this embodiment. The block diagram which shows the functional structure realized in the debug support apparatus in this embodiment. The flowchart explaining the process of the small difference list initialization part of 1st Embodiment. The flowchart explaining the process of the test-passing intermediate source code and the data file initialization part of 1st Embodiment. The flowchart explaining the process of the test failure small difference list search part of 1st Embodiment. The figure which shows an example of the data table of a test passing source code and a data file. The figure which shows an example of the data table of the test failure source code and a data file. The figure which shows an example of the data table of a small difference list. The figure which shows an example of the data table of the small difference combination selection candidate list. The figure which shows an example of the data table of the small difference combination to be selected. The figure which shows an example of the data table of the test passing intermediate source code and a data file. The figure which shows an example of the data table of the intermediate source code and a data file which passed the update test. The figure which shows an example of the data table of the update small difference list. The figure which shows an example of the data table of the small difference list at the end. The figure which shows an example of the data table of the intermediate source code and the data file which passed the examination at the end. The block diagram which shows the structure of the debug support apparatus of 2nd Embodiment. The figure which shows an example of the data table of the small difference combination selection candidate list of 3rd Embodiment.

Hereinafter, embodiments will be described with reference to the drawings.
(First Embodiment)
The debug support device and the debug support program of the first embodiment extract the difference between the version A source code and data file in which the program passed the test and the version B source code and data file in which the program failed. Create a subdivided list of small differences, apply the combination of small differences extracted from the above small difference list to the source code and data files that passed the test, and repeat the test to pass. By updating the list of small differences and the source code and data files that passed the test using the small difference combination that became, search for the smallest combination of small differences that fails the test while pruning. To do.

This makes it possible to automatically and efficiently identify the factors that cause the source code or data file to fail the test, without the need to rely on the skills, knowledge, and rules of thumb of the developer.

FIG. 1 is a block diagram showing a configuration of the debug support device 1 according to the first embodiment. The debug support device 1 is realized by, for example, a personal computer. The debug support device 1 includes a processor 2, a memory 3, a storage device 4, an input device 5, and a display device 6.

The processor 2 executes a basic program (OS) or an application program stored in the memory 3 to realize various functions. For example, the processor 2 operates the personal computer as the debug support device 1 by executing the debug support program. The processor 2 executes the debug support process by executing the debug support program according to the present embodiment, and operates the personal computer as the debug support device 1.

The memory 3 stores a program executed by the processor 2, temporary data, and the like. For example, the memory 3 stores various programs such as the debug support program 4A read from the storage device 4, as well as data used in various processes.

The storage device 4 stores various programs and various data. The program stored in the storage device 4 includes the debug support program 4A. Further, the storage device 4 is provided with a storage unit 10 for storing data used in the test support process based on the debug support program 4A.

The display device 6 is an LCD (Liquid Crystal Display) or the like, and displays a screen corresponding to the processing of the processor 2. The input device 5 is a keyboard, a pointing device, or the like, and is operated by an operator or the like.

FIG. 2 is a block diagram showing a functional configuration realized by executing the debug support program 4A by the processor 2 in the debug support device 1 in the present embodiment. The debug support device 1 includes a storage unit 10 and a debug support processing unit 20.

The storage unit 10 includes a test pass source code and data file storage unit 11, a test fail source code and data file storage unit 12, a test pass source code and data file storage unit 13, and a small difference list storage unit 14.

The debug support processing unit 20 includes a small difference list initialization unit 21, a test pass intermediate source code and data file initialization unit 22, and a test fail small difference list search unit 23.

The test-passing source code and data file storage unit 11 stores the data table 111 of the test-passing source code and data file as the source code and data file of a specific version that has passed the test.

The test-failed source code and data file storage unit 12 stores the data table 121 of the test-failed source code and data file as another version of the source code and data file that failed the test.

The intermediate source code and data file that passed the test The storage unit 13 used the intermediate source code and data file that passed the test as the intermediate source code and data file that passed the test while searching for a combination of small differences that failed the test. The data table 131 is stored.

The small difference list storage unit 14 is in the process of searching for a combination of small differences that fails the test, and sets the data table 131 of the intermediate source code and data file that passed the test and the data table 121 of the source code and data file that failed the test. The data table 141 of the small difference list is stored as the small difference list in which the differences are subdivided.

The small difference list initialization unit 21 acquires the data table 111 of the test pass source code and data file from the test pass source code and data file storage unit 11, and fails the test from the test fail source code and data file storage unit 12. The data table 121 of the source code and the data file is acquired, the difference between the two is extracted to create a subdivided small difference list, and the data table 141 of the small difference list is stored in the small difference list storage unit 14 as the initial state. To do.

The test pass intermediate source code and data file initialization unit 22 acquires the test pass source code and data file data table 111 from the test pass source code and data file storage unit 11, and the test pass intermediate source code and data file data. As the initial state of the table 131, the test-passed intermediate source code and the data file storage unit 13 are stored.

The test-failed small difference list search unit 23 acquires the data table 131 of the test-passed intermediate source code and data file from the test-passed intermediate source code and data file storage unit 13, and from the small-difference list storage unit 14 of the small-difference list. The data table 141 and the data table 142 of the small difference combination selection candidate list are acquired, the small difference combination 143 is selected, and based on the result of the test execution process, the data table 144 of the updated small difference list is used to store the small difference list storage unit 14. By repeatedly updating the data table 132 of the intermediate source code and the data file that passed the update test, the data table 145 and the test at the end of the small difference list at the end were repeatedly updated. The data table 133 of the pass source code and the data file is output.

The data table 145 of the end small difference list is the smallest combination of small differences that fails the test, which is the purpose of the search.

The data table 133 of the source code and data file that passed the test at the end corresponds to the smallest combination of small differences that pass the test, and the source code that applies the largest combination of small differences that pass the test. It is a data file.

In the first embodiment, the combination of small differences that passes the test is searched for, but for example, the combination of small differences that is less than or equal to a predetermined number may be searched.

Next, the operation of the debug support device 1 of the first embodiment will be described with reference to the flowcharts shown in FIGS. 3, 4, and 5.
FIG. 3 is a flowchart illustrating the processing of the small difference list initialization unit 21 of the first embodiment. The small difference list initialization unit 21 executes the difference calculation process (step 211) and the subdivision process (step 212).

First, the difference calculation process (step 211) by the small difference list initialization unit 21 will be described.
The small difference list initialization unit 21 acquires the data table 111 of the test pass source code and data file from the test pass source code and data file storage unit 11, and fails the test from the test fail source code and data file storage unit 12. Acquire the data table 121 of the source code and the data file. Further, the small difference list initialization unit 21 calculates the difference between the data table 111 of the data file and the test-failed source code and the data table 121 of the data file. At that time, for the difference calculation process 211, for example, a Wu algorithm or a dynamic programming method, which is a commonly used difference calculation method, or a diff tool that implements them can be used.

FIG. 6 is a diagram showing an example of a data table 111 of a test-passing source code and a data file. The file path (file name) and the contents of the file are stored in the data table 111 of the test-passing source code and the data file.

FIG. 7 is a diagram showing an example of the data table 121 of the test-failed source code and the data file. The data table 121 of the test-failed source code and the data file stores the file path (file name) and the contents of the file.

Next, the subdivision process (step 212) by the small difference list initialization unit 21 will be described.
The small difference list initialization unit 21 subdivides the difference calculated by the difference calculation process into small differences, and stores the difference as the initial state of the data table 141 of the small difference list in the small difference list storage unit 14. As the unit for subdividing into small differences, for example, one line of the differences is defined as one small difference, or consecutive lines of the differences are defined as one small difference. In the case of the data tables 111 and 121 shown in FIGS. 6 and 7, for example, for a data file whose file name is "family.txt", one line of the difference is set as one minor difference, and the file name is "discount.c". For the source code, the continuous line of the difference is set as one small difference.

When one line of the difference is one small difference, the combination of small differences that fails the minimum test can be calculated for each line, but the processing time is larger than the latter because there are more combinations of small differences to be searched. Becomes longer. When consecutive lines of the difference are set as one small difference, the number of combinations of small differences to be searched is smaller than that of the former, so that the processing time is shortened. Only the combination of differences can be calculated, and one small difference is larger than or the same as the combination of small differences that causes the minimum test failure in line units.

In the subdivision processing by the small difference list initialization unit 21 described above, one line of the difference is set as one small difference for the data file, and one continuous line of the difference is set as one small difference for the source code. It is not limited to this.

FIG. 8 is a diagram showing an example of the data table 141 of the small difference list. The data table 141 of the small difference list contains a serial number ID assigned to each small difference, a file path (file name), an operation type (insert, delete, replace), a pass side line range, and a fail side line range. And the contents of the failing side of the difference are stored.

FIG. 4 is a flowchart illustrating the processing of the test-passing intermediate source code and the data file initialization unit 22 of the first embodiment. The test-passing intermediate source code and data file initialization unit 22 executes a copy process (step 221).

The test pass intermediate source code and data file initialization unit 22 acquires the test pass source code and data file data table 111 from the test pass source code and data file storage unit 11 by copy processing, and tests this data table 111. The pass intermediate source code and data file are stored in the test pass intermediate source code and data file storage unit 13 as the initial state of the data table 131 of the pass intermediate source code and data file.

FIG. 11 is a diagram showing an example of the data table 131 of the test-passing intermediate source code and the data file. The data table 131 of the intermediate source code and the data file that passed the test stores the file path (file name) and the contents of the file.

FIG. 5 is a flowchart illustrating the processing of the test failure small difference list search unit 23 of the first embodiment. The test failure small difference list search unit 23 includes a small difference combination loop process (step 231), a small difference combination acquisition process (step 232), a difference application process (step 233), a test execution process (step 234), and an intermediate test pass. The source code and data file update process (step 235), the small difference list update process (step 236), the end of the small difference combination loop (step 237), and the pass determination process (step 238) are executed.

The test failure small difference list search unit 23 acquires the data table 142 of the small difference combination selection candidate list by the small difference combination loop processing (step 231), selects each row of the list in order, and performs the small difference combination acquisition processing. (Step 232) and subsequent steps are executed.

FIG. 9 is a diagram showing an example of the data table 142 of the small difference combination selection candidate list. The data table 142 of the small difference combination selection candidate list stores a list of all combinations of serial number IDs of the data table 141 of the small difference list without omission. That is, all the combinations of small differences are defined in the data table 142 of the small difference combination selection candidate list.

The test-failed small difference list search unit 23 uses the small difference combination acquisition process (step 232) to correspond to the row selected in the small difference combination loop process 231 in the data table 142 of the small difference combination selection candidate list. The row of the data table 141 of the difference list is acquired as the data table 143 of the selected small difference combination.

FIG. 10 is a diagram showing an example of the data table 143 of the selection target small difference combination. In the data table 143 of the small difference combination to be selected, the serial number ID, the file path (file name), the operation type (insert, delete, replace), the pass side line range, the fail side line range, and the difference are not found. The contents of the passing side are stored. FIG. 10 is a data table 143 of the selection target small difference combination corresponding to the row corresponding to the ID combination “1” shown in FIG. For example, in the data table 143 of the selection target small difference combination corresponding to the ID combination “1, 2, 3” shown in FIG. 9, the data of the serial number ID “1, 2, 3” is included.

The test-failed small-difference list search unit 23 uses the difference application process (step 233) to refer to the data table 131 of the test-passed intermediate source code and data file with the contents (small difference) of the data table 143 of the selected small difference combination. ) Is applied to generate the source code and data file to be tested. When the operation type of the data table 143 of the selected small difference combination is "insert", the test-failed small difference list search unit 23 inserts the contents of the failing side of the difference in the corresponding line, and the operation type is "delete". In the case of "", the corresponding line is deleted, and in the case of the operation type "Replace", the corresponding line is replaced with the contents of the failing side of the difference. In that case, a commonly used patch tool can be used.

The test failure small difference list search unit 23 tests the source code and the data file after applying the difference by the test execution process (step 234). The test-failed small difference list search unit 23 determines whether the test has passed or failed as a result of conducting the test on the source code and the data file after applying the difference (step 238). When it is determined that the test has passed, the test-failed small difference list search unit 23 executes the test-passed intermediate source code and data file update process (step 235) and the small difference list update process (step 236).

The test-failed small difference list search unit 23 uses the test-passed intermediate source code and data file update process (step 235) to update the data of the updated test-passed intermediate source code and data file, which are the source code and data file after applying the difference. Update the data table 131 of the test pass intermediate source code and data file in table 132.

FIG. 12 is a diagram showing an example of the data table 132 of the intermediate source code and the data file that passed the update test. The data table 132 of the intermediate source code and the data file that passed the update test stores the file path and the contents of the file. The data table 132 shown in FIG. 12 is obtained by applying the contents of the data table 143 of the selection target small difference combination shown in FIG. 10 to the data table 131 of the test-passing intermediate source code and the data file shown in FIG. , The second line "#include <stdio.h>" of the source code whose file name is "discount.c" has been deleted.

Further, the test-failed small-difference list search unit 23 deletes the combination of the small-differences from the data table 141 of the small-difference list when the test is passed by the small-difference list update process (step 236), and sets the pass side row. The data table 141 of the small difference list is updated with the data table 144 of the updated small difference list, which has been updated to correspond to the data table 132 of the intermediate source code and the data file that passed the update test.

The test-failed small-difference list search unit 23 updates the data table 141 of the small-difference list, the test-passed intermediate source code, and the data file 131, and then executes the loop processing from the beginning of the small-difference combination loop processing 231. At this time, the number of elements in the data table 141 of the small difference list is reduced by one or more compared to the start of the previous small difference combination loop process 231, and the expected number of repetitions until the small difference combination loop process 231 ends is expected. The value is decreasing.

FIG. 13 is a diagram showing an example of the data table 144 of the update small difference list. The data table 144 of the update small difference list shows the serial number ID, the file path (file name), the operation type (insert, delete, replace), the pass side line range, the fail side line range, and the difference failure. The contents of the side are stored.

On the other hand, when the test failure small difference list search unit 23 determines that the test fails as a result of conducting the test on the source code and the data file after applying the difference (step 238, fails), the small difference combination loop termination. In (step 237), if the test fails and there is a remaining small difference combination, the next combination is selected and the processing after the small difference combination loop processing 231 is restarted. The test failure small difference list search unit 23 ends the process when the test fails and there is no remaining small difference combination in the data table 142 of the small difference combination selection candidate list.

At the end of processing, the test-failed small-difference list search unit 23 outputs the data table 141 of the small-difference list as the data table 145 of the small-difference list at the end, and ends the data table 131 of the test-passed intermediate source code and data file. When the test is passed, it is output as the data table 133 of the intermediate source code and the data file.

FIG. 14 is a diagram showing an example of the data table 145 of the end small difference list. The data table 145 of the small difference list at the end shows the serial number ID, the file path (file name), the operation type (insert, delete, replace), the pass side line range, the fail side line range, and the difference. The contents of the passing side are stored. The items in the data table 145 of the small difference list at the end are composed of the root cause part of the test failure in the small difference unit and the part depending on the root cause part.

As shown in FIG. 14, from the data table 145 of the small difference list at the end, the contents of the pass side line range “15” and the fail side line range “15” of the source code of the file name “discount.c” and the file. It can be identified that the contents of the pass side line range "13" and the fail side line range "14" of the data file with the name "family.txt" are the degradation factor points.

FIG. 15 is a diagram showing an example of data table 133 of the intermediate source code and the data file that passed the final test. The data table 133 of the intermediate source code and the data file that passed the test at the end stores the file path and the contents of the file.

The data table 133 of the intermediate source code and the data file that passed the test at the end is composed of a combination of small differences that pass the test, not including the contents of the data table 145 of the small difference list at the end shown in FIG.

In this way, in the debug support device 1 of the first embodiment, the version A source code and data file (test pass source code and data file data table 111) in which the program passed the test are rejected. A subdivided list of small differences (data table 141 of the small difference list) is created by extracting the differences from the version B source code and data file (data table 121 of the test-failed source code and data file). , Repeat the test by applying the combination of small differences extracted from the small difference list to the source code and data file that passed the test, and use the small difference combination that passed the test to create a list of small differences. By updating the source code and data file that passed the test, it is possible to search for the smallest combination of small differences that fail while pruning (discontinuing unnecessary searches). That is, by specifying the degradation point not in units of commits to source code and data files, but in units of small difference combinations that make up commits, differences are based on the skills, knowledge, and rules of thumb of developers. It is not necessary to analyze the factors that change the pass / fail of the test, and it is possible to automatically and efficiently identify the factors that cause the test to fail in the source code or data file.

(Second Embodiment)
Next, the debug support device 1B of the second embodiment will be described.
FIG. 16 is a block diagram showing a configuration of the debug support device 1B of the second embodiment. The debug support device 1B of the second embodiment includes a storage unit 10, a debug support processing unit 20A, and a debug support processing unit 20B. The debug support device 1B is basically configured in the same manner as the debug support device 1 of the first embodiment, and the components with the same names are described in detail as the same as those of the first embodiment. Omit.

The storage unit 10 includes a test pass source code and data file storage unit 11, a test fail source code and data file storage unit 12, a test pass source code and data file storage unit 13, and a small difference list storage unit 14. Be prepared.

The debug support processing unit 20A includes a small difference list initialization unit 21 and a test-passing intermediate source code and data file initialization unit 22.

The debug support processing unit 20B includes a plurality of test-failed small difference list search units 23 (23-3, 23-2, 23-3). The plurality of test-failed small-difference list search units 23 select different small-difference combinations from the data table 142 of the small-difference combination selection candidate list, and search for the test-failed small-difference list of the first embodiment in parallel. The process is executed in the same manner as in the part 23.

As described above, according to the debug support device 1B of the second embodiment, since a plurality of test-failed small difference list search units 23 are arranged in parallel, each test-failed small difference list search unit 23 is different. Since it is possible to select a combination of small differences and search in parallel at the same time, the processing time can be shortened. When a round-robin search is performed for all the small difference combinations in the data table 142 of the small difference combination selection candidate list, the number of combinations increases as the number of small differences increases, and the test failure small difference list search unit 23 Although the number of repetitions of the process in is extremely large, it is possible to keep the time required for the search to be completed within a realistic range by providing a plurality of test-failed small difference list search units 23 and processing in parallel. Become.

The debug support device 1B shown in FIG. 16 is provided with three test-failed small difference list search units 23-3, 23-2, and 23-3, but the number is not limited to three.

(Third Embodiment)
Next, the third embodiment will be described. The third embodiment changes the small difference combination loop processing (step 231) in the test failure small difference list search unit 23 of the debug support device 1 of the first embodiment and the debug support device 1B of the second embodiment.

In the small difference combination loop processing (step 231B) of the third embodiment, the data table 142B of the small difference combination selection candidate list is acquired, each row of the list is selected in order, and the small difference combination acquisition processing (step 232) and subsequent steps are performed. Execute.

In the data table 142B of the small difference combination selection candidate list of the third embodiment, the small difference combinations (all combinations of serial number IDs) shown in FIG. 9 described in the first embodiment are used as the data of the small difference combination selection candidate list. They are sorted in descending order of probability of passing the exam based on prior information about Table 142B.

The rearrangement of the combination of small differences can be executed, for example, as follows.

As one of the examples of prior information regarding the data table 142B of the small difference combination selection candidate list, if it is clear from parsing or the like that one of the small difference combinations A1 depends on the other small difference A2, A2 is used. There is a thing that A1 that does not include is always rejected. The small difference combinations that do not seem to depend on other small difference combinations are listed first, and the small difference combinations that clearly depend on other small difference combinations are listed later.

As one of the examples of the prior information regarding the data table 142B of the small difference combination selection candidate list, if one of the small difference combinations B1 fails, even if the small difference B2 that B1 does not depend on is added, it always fails. However, if B1 passes, adding the small difference B3 may result in failure. Therefore, the smaller the number of small differences included in the combination, the higher the probability of passing the test. As in the example of the data table 142 of the small difference combination selection candidate list, the combinations are arranged in order from the one with the smallest number of small differences.

As an example of prior information about the data table 142B of the small difference combination selection candidate list, if one of the small difference combinations C1 fails in the previous loop, C1 depends on the last updated small difference combination C2. Otherwise, the loop will always fail, so there is a higher probability that the untested small difference combination will pass the test than the small difference combination that failed in the previous loop. The small difference combinations that have not been tested in the previous loop are listed first, and the small difference combinations that failed in the previous loop are listed later.

FIG. 17A is a diagram showing an example of the data table 142B of the small difference combination selection candidate list in which the small difference combinations are arranged in descending order of probability of passing the test. Note that FIG. 17B shows the reason for rearranging each small difference combination shown in FIG. 17A.

For example, regarding the small difference combination of the serial number ID "2" shown in FIG. 17 (A), the insertion of the constant definition can be identified by parsing without semantic analysis, and it is unlikely that it depends on other small differences. Since it can be assumed, it is arranged in the front of the small difference combination. Similarly, the small difference combinations of the serial number IDs "4" to "8" are arranged in the front of the small difference combinations because it can be assumed that the insertion of the data definition is unlikely to depend on other small differences.

Further, since it can be assumed that the combination with a smaller number of small differences is less likely to depend on other small differences, after enumerating the combinations with one small difference (serial number IDs "1" to "8"), the small difference The numbers are arranged so as to enumerate combinations of two (serial number IDs "2, 4", "2, 5" ...).

The data table 142B of the small difference combination selection candidate list may be generated by the small difference list initialization unit 21, or the test failure small difference list search unit 23 selects the small difference combination in the small difference combination loop processing 231. It may be generated based on the data table 142 of the candidate list.

In this way, in the debug support device 1 or the debug support device 1B of the third embodiment, the small difference combinations are arranged in order from the small difference combination having a high probability of passing the test in the data table 142B of the small difference combination selection candidate list. It is possible to reduce the expected value of the number of searches until the data table 141 of the difference list and the data table 142 of the small difference combination selection candidate list are updated. Therefore, the processing time can be shortened by using the prior information regarding the data table 142B of the small difference combination selection candidate list.

(Fourth Embodiment)
Next, the fourth embodiment will be described. The fourth embodiment changes the small difference combination loop processing (step 231) in the test failure small difference list search unit 23 of the debug support device 1 of the first embodiment and the debug support device 1B of the second embodiment.

The small difference combination loop process (step 231C) of the fourth embodiment acquires the data table 142 of the small difference combination selection candidate list, selects each row of the list in order, and executes the small difference combination acquisition process 232 and subsequent steps. At this time, the data table 142 of the small difference combination selection candidate list excludes selection candidates whose number of small differences included in the combination (number of combinations of small differences) exceeds a certain cutoff value, and the number of small differences sets the cutoff value. Only the selection candidates that do not exceed shall be left.

For example, if the test execution process (step 234) is performed on a small difference combination having four small difference combinations (number of combinations) and the test fails, the test fails on five or more small difference combinations. Is likely to be. Therefore, by excluding the selection candidates in which the number of small differences included in the combination exceeds a certain number (in this case, the number of three or four small differences), ineffective processing is prevented from being executed.

In this way, in the debug support device 1 or the debug support device 1B of the fourth embodiment, the selection candidates that exceed the cutoff value are excluded from the selection candidates of the data table 142 of the small difference combination selection candidate list, so that the selection candidates are selected. Since it is possible to reduce the number, the processing time can be shortened at the cost of lowering the search accuracy.

The methods described in each of the above embodiments include magnetic disks (flexible disks, hard disks, etc.), optical disks (CD-ROM, DVD, etc.), optical magnetic disks (MO), and so on, as programs that can be executed by a computer. It can also be stored and distributed in a storage medium such as a semiconductor memory.

Further, the storage medium may be in any form as long as it is a storage medium capable of storing a program and readable by a computer.

Further, in order for the OS (operating system) running on the computer, the database management software, the MW (middleware) such as the network software, etc. to realize the above embodiment based on the instruction of the program installed on the computer from the storage medium. You may execute a part of each process of.

Further, the storage medium in each embodiment is not limited to a medium independent of the computer, but also includes a storage medium in which a program transmitted by a LAN, the Internet, or the like is downloaded and stored or temporarily stored.

Further, the storage medium is not limited to one, and the case where the processing in each of the above embodiments is executed from a plurality of media is also included in the storage medium in the present invention, and the medium configuration may be any configuration.

The computer in each embodiment executes each process in each of the above embodiments based on the program stored in the storage medium, and is composed of one device such as a personal computer and a plurality of devices in a network. Any configuration such as a connected system may be used.

Further, the computer in each embodiment is a general term for a device and a device capable of realizing the function of the present invention by a program, including an arithmetic processing device, a microcomputer and the like included in the information processing device.

Although some embodiments of the present invention have been described, these embodiments are presented as examples and are not intended to limit the scope of the invention. These novel embodiments can be implemented in various other embodiments, and various omissions, replacements, and changes can be made without departing from the gist of the invention. These embodiments and modifications thereof are included in the scope and gist of the invention, and are also included in the scope of the invention described in the claims and the equivalent scope thereof.

1 ... Debug support device, 2 ... Processor, 3 ... Memory, 4 ... Storage device, 4A ... Debug support program, 10 ... Storage unit, 11 ... Test pass source code and data file storage unit, 12 ... Test failure source code and Data file storage unit, 13 ... Test pass source code and data file storage unit, 14 ... Small difference list storage unit, 20, 20A, 20B ... Debug support processing unit, 21 ... Small difference list initialization unit, 22 ... Test pass intermediate Source code and data file initialization unit, 23,23-1,23-2,23-3 ... Test failure small difference list search unit.

Claims (7)

Extract the difference between the first data table of the first test pass source code and data file stored in the first storage unit and the second data table of the test failure source code and data file stored in the second storage unit. A small difference list initialization unit that creates a subdivided list of small differences and stores it in the third storage unit,
The test is repeated by applying the combination of small differences included in the list to the source code and data file that passed the first test, and the combination of small differences that fails the test is searched for and output. A debug support device that has a list search unit. The debug support device according to claim 1, wherein the small difference list search unit searches for the minimum combination that fails the test. The debug support device according to claim 1 or 2, wherein the small difference list search unit creates a second test pass source code and a data file based on a combination of small differences that pass the test. The debug support device according to any one of claims 1 to 3, wherein a plurality of small difference list search units are provided, and tests are performed in parallel based on different combinations of small differences included in the list. The small difference list search unit rearranges a plurality of combinations of small differences included in the list based on prior information about the probability of passing the test, and is a combination of small differences having a high probability of passing the test. The debug support device according to any one of claims 1 to 4, wherein the test is performed by applying the first test pass source code and the data file in order. The small difference list search unit excludes the small difference combinations in which the number of small difference combinations exceeds a certain number from the small difference combinations included in the list, and obtains the source code and data file that passed the first test. The debug support device according to any one of claims 1 to 5, wherein the test is applied and tested. Computer,
Extract the difference between the first data table of the first test pass source code and data file stored in the first storage unit and the second data table of the test failure source code and data file stored in the second storage unit. A small difference list initialization unit that creates a subdivided list of small differences and stores it in the third storage unit,
The test is repeated by applying the combination of small differences included in the list to the source code and data file that passed the first test, and the combination of small differences that fails the test is searched for and output. A debug support program to function as a list search unit.

Images