JP5682109B2 - Coverage information generation program, coverage information generation apparatus, and coverage information generation method - Google Patents

Description

  The present invention relates to a coverage information calculation program, a coverage information calculation device, and a coverage information calculation method.

  2. Description of the Related Art Conventionally, when testing a developed program or a development stage program, a technique using coverage information is used as a technique for preventing test omission of each code such as a program class, method, function, and subroutine. As an example of such a coverage information calculation method, there is disclosed a coverage information calculation device that calculates an “execution coverage rate” indicating how many lines to be executed described in a program are actually executed. .

  Specifically, the coverage information calculation device records an “execution position” indicating where the program has been executed as log data during program execution, and displays an “execution line” indicating the number of types of execution positions from the recorded execution position. Count "number". Then, the coverage information calculation device divides the counted “execution line number” by the “effective total line number” indicating the number of executable lines of the entire program, and further multiplies the result by “100”. Calculate as coverage information. The higher the “execution coverage rate” calculated in this way, the more lines that are to be executed described in the program are actually executed. In addition, the lower the “execution coverage rate”, the more lines that are to be executed described in the program are not actually executed.

  Here, a coverage information calculation apparatus that calculates an “execution coverage rate” as coverage information will be described more specifically with reference to FIGS. 11 and 12. FIG. 11 is a diagram illustrating an example of acquiring the execution position at the time of program execution, and FIG. 12 is a diagram illustrating an example of acquiring the number of execution lines from the execution position.

  As shown in FIG. 11, a program having class A, class B, and class C is executed on a Java (registered trademark) VM (Java (registered trademark) Virtual Machine). Then, the coverage information calculation apparatus stores “class name”, “method name”, and “valid row number” in association with each other as a configuration of the program, and further stores “valid total row number”. Here, the “class name” is information indicating the name of a class that defines an object in which data and a method that is a processing method thereof are collected. The “method name” is information indicating the name of the method defined in the class, and the “effective line number” is information indicating the line number in the class to be executed. The “number of valid total lines” is information obtained by counting the number of “valid line numbers” of each class, and is information indicating the total number of lines to be executed in the entire program.

  For example, as shown in FIG. 11A, the coverage information calculation apparatus has “classA, methodA1, 3, 4, 5, 6” or “classA, methodA2, “9, 10, 13”. Also, the coverage information calculation device stores “classB, methodB1, 1, 2, 4, 5”, “classB, methodB2, 8, 9, 12”, “classB, methodB3, 13, 14, 16, 19”. . Then, the coverage information calculation device stores “classC, methodC1, 2, 3, 4, 5, 7, 9” and “24” as the “number of valid entire lines”.

  That is, in this example, classA is methodA1 which is the executable line from the 3rd to 6th lines of the program, and methodA2 which is the executable line from the 9th, 10th and 13th lines of the program. And have. In addition, classB includes methodB1, which is an executable line for the first, second, fourth, and fifth lines of the program, and methodB2, which is an executable line for the eighth, ninth, and twelfth lines of the program. Furthermore, classB has methodB3 which is a line in which the 13th, 14th, 16th, and 19th lines of the program can be executed. In addition, classC has methodC1, which is an executable line of the second, third, fourth, fifth, seventh, and ninth lines of the program.

  In such a state, when the coverage information calculation device executes a program having class A to C on Java (registered trademark) VM, it displays an “execution position” indicating the executed “class name, method name, line number”. Output to a file as log data. For example, the coverage information calculation apparatus outputs “classA, methodA1, line 3”, “classA, methodA1, line 4”, “classB, methodB2, line 8” as shown in FIG. To do. Further, the coverage information calculation device outputs “classB, methodB2, line 9”, “classB, methodB2, line 12”, “classB, methodB2, line 8”, “classB, methodB2, line 9”. . Also, the coverage information calculation apparatus outputs “classB, methodB2, line 12” and “classA, methodA1, line 5”.

  Thereafter, the coverage information calculation apparatus counts the type of the “execution position” that is output when the execution of the program is stopped or when the program ends. For example, as shown in FIG. 12, the coverage information calculation apparatus counts the number of appearances of “classA, methodA1, third line” as “1” and the number of appearances of “classA, methodA1, fourth line” as “1”. To do. Similarly, the coverage information calculation apparatus counts the number of appearances of “classA, methodA1, line 5” as “1”. Furthermore, the coverage information calculation device sets the number of appearances of “classB, methodB2, line 8” to “2”, the number of appearances of “classB, methodB2, line 9” to “2,” “classB, methodB2, line 12” "2" is counted as "2". Therefore, the coverage information calculation apparatus counts that all six types of “execution positions”, in other words, all six types of “rows” have been executed.

  Then, the coverage information calculation device calculates “6/24 = 0.25” by dividing the calculated “execution position” type number “6” by “valid total number of rows = 24”, and further sets 100 to “0.25”. The multiplied “25” is calculated as the “execution coverage rate”. As a result, it can be seen that “25%” of the entire illustrated program is actually executed and “75%” is not actually executed.

JP 9-251400 A

  However, in the conventional technique, when the program for which coverage information is to be calculated is complex, the data output by executing the program and storing data necessary for calculating the coverage information become enormous. As a result, there is a problem that coverage information cannot be calculated efficiently.

  For example, when calculating the “execution coverage rate” of the entire program, the coverage information calculation apparatus executes the program from the beginning to the end to obtain the “execution position”. Further, every time a line in the program is executed, the coverage information calculation apparatus outputs “execution position” one line at a time as log data. For these reasons, the coverage information calculation apparatus outputs a huge number of “execution positions” as log data when calculating the coverage of a complex program or a large-scale program. The coverage information calculation device requires a lot of time to count the type of “execution position” from the enormous number of “execution positions” that are output, and as a result, it also requires a lot of calculation for the “execution coverage ratio”. I need time.

  When calculating the “execution coverage rate” of a predetermined range of the program, the coverage information calculation device executes the program within the predetermined range and acquires the “execution position”. When calculating the “execution coverage rate” of such a predetermined range, the target program of the predetermined range is often very complicated. For this reason, the number of “execution positions” output by executing a program within a predetermined range is often enormous. Therefore, even in this case, the coverage information calculation device requires a lot of time to count the types of “execution positions” from the enormous number of “execution positions” that are output. It takes a lot of time to calculate "".

  When calculating the “execution coverage rate” of a program that is repeatedly executed, the coverage information calculation apparatus executes the program for a predetermined time to obtain the “execution position”. In this case, the longer the program execution time is, the more “execution positions” are output as log data. In other words, the longer the program execution time is, the longer the coverage information calculation device needs time to count the type of “execution position” from the output “execution position”, and the more the “execution coverage rate” is calculated. Need time.

  The disclosed technology has been made in view of the above, and a coverage information calculation program and a coverage information calculation apparatus capable of efficiently calculating coverage information regardless of a program for which coverage information is to be calculated It is another object of the present invention to provide a coverage information calculation method.

  The coverage information calculation program disclosed in the present application uses a counter provided for each code framework included in the program for which coverage information is to be calculated, and counts the number of times the framework has been executed when the program is executed. A frequency counting procedure. A coverage information calculation procedure for calculating coverage information from the number of frames provided with the counter and the number of frames for which the number of executions is counted by the number counting procedure is provided. Then, the computer is caused to execute these procedures.

  According to one aspect of the coverage information calculation program, the coverage information calculation device, and the coverage information calculation method disclosed in the present application, it is possible to efficiently calculate the coverage information regardless of the program that is the calculation target of the coverage information. There is an effect that there is.

FIG. 1 is a block diagram illustrating the configuration of the coverage information calculation apparatus according to the first embodiment. FIG. 2 is a block diagram illustrating the configuration of the coverage information calculation apparatus according to the second embodiment. FIG. 3 is a diagram illustrating an example of information stored in the program DB. FIG. 4 is a diagram illustrating an example of information stored in the framework counter DB when the program is described in C language. FIG. 5 is a diagram illustrating an example of information stored in the framework counter DB when a program is described in Java (registered trademark). FIG. 6 is a diagram illustrating an example of information stored in the coverage information DB. FIG. 7 is a diagram illustrating an example of extracting a framework from source code described in C language. FIG. 8 is a diagram illustrating an example of extracting a framework from a source file described in Java (registered trademark). FIG. 9 is a flowchart illustrating a process flow in the coverage information calculation apparatus according to the second embodiment. FIG. 10 is a diagram illustrating an example of a computer system that executes a coverage information calculation program. FIG. 11 is a diagram illustrating an example in which an execution position is acquired during program execution. FIG. 12 is a diagram illustrating an example of acquiring the number of execution lines from the execution position.

  Hereinafter, embodiments of a coverage information calculation program, a coverage information calculation device, and a coverage information calculation method disclosed in the present application will be described in detail with reference to the drawings. Note that the present invention is not limited to the embodiments.

  FIG. 1 is a block diagram illustrating the configuration of the coverage information calculation apparatus according to the first embodiment. A coverage information calculation apparatus 1 illustrated in FIG. 1 is an apparatus that tests a program under development and calculates an execution coverage rate in arbitrary units such as line coverage, class coverage, and method coverage. As shown in FIG. 1, the coverage information calculation apparatus 1 includes a number counting unit 1a and a coverage information calculation unit 1b.

  The number counting unit 1a counts the number of times the framework has been executed when the program is executed, using a counter provided for each code framework included in the program for which coverage information is to be calculated. For example, the coverage information calculation apparatus 1 stores, in a memory or the like, a counter for each code framework included in the program source code 2 that is a coverage information calculation target. The number counting unit 1a executes the program source code 2 and counts the number of times executed for each framework of the program source code 2 using a counter for each framework stored in a memory or the like. Thereafter, when the execution of the program source code 2 is completed, the number counting unit 1a notifies the coverage information calculation unit 1b that the execution of the program is completed.

  The coverage information calculation unit 1b calculates coverage information from the number of frames provided with a counter and the number of frames for which the number of executions is counted by the number counting unit 1a. For example, the coverage information calculation unit 1b calculates the coverage information 3 in arbitrary units such as line coverage, method coverage, class coverage, and function coverage. As an example, the coverage information calculation unit 1b includes an execution coverage ratio indicating how many lines to be executed in the program are actually executed, and an execution coverage ratio indicating how many functions to be executed in the program are actually executed. Etc. are calculated.

  As described above, according to the first embodiment, the coverage information calculation apparatus 1 provides a counter or the like corresponding to the framework of a program for which coverage information is calculated in a memory or the like. Then, the coverage information calculation apparatus 1 counts the number of frames actually executed by incrementing a counter provided in the memory, and calculates an execution coverage rate and the like. That is, it is not necessary for the coverage information calculation apparatus 1 to output execution log data to a file or a memory each time a program is executed, and it is sufficient to count only the number of executions using a counter corresponding to the scale of the program.

  Therefore, in the coverage information calculation apparatus 1 according to the first embodiment, even if the program is complicated, an area for storing data that is output by executing the program and necessary for calculating coverage information is necessary. Absent. Further, in the coverage information calculation apparatus 1 according to the first embodiment, the number of executions is counted each time the program is executed by the counter for each framework created before the execution of the program. Therefore, for each framework from the log data output by the execution of the program. There is no need to analyze the number of executions.

  As a result, the coverage information calculation apparatus 1 according to the first embodiment can efficiently calculate the coverage information regardless of the program that is the calculation target of the coverage information. In addition, a program developer or the like can quickly confirm a test omission of each code such as a class, a method, a function, and a subroutine of a program under development.

  By the way, the coverage information calculation apparatus disclosed in the present application may have various control units other than the control unit described in the first embodiment. Thus, in the second embodiment, a coverage information calculation apparatus having various control units other than the control unit described in the first embodiment will be described.

[Configuration of coverage information calculation device]
First, the configuration of a coverage information calculation apparatus having various control units will be described with reference to FIG. FIG. 2 is a block diagram illustrating the configuration of the coverage information calculation apparatus according to the second embodiment. As illustrated in FIG. 2, the coverage information calculation apparatus 10 includes a communication control I / F unit 11, an input unit 12, a display unit 13, a storage unit 15, and a control unit 20.

  The communication control I / F unit 11 is an interface having at least one communication port, and controls information exchanged with other devices. For example, the communication control I / F unit 11 is connected to a management computer used by a program developer, receives a coverage information calculation target program from the management computer, and transmits the calculated coverage information to the management computer.

  The input unit 12 is, for example, a keyboard, a mouse, a microphone, and the like. The input unit 12 can read information from and write information to a storage medium such as a CD (Compact Disc), a DVD (Digital Versatile Disc), or a magnetic disk. For example, the input unit 12 can read a coverage information calculation target program from the storage medium and store it in the storage unit 15 or write the calculated coverage information to the storage medium.

  Note that the display unit 13 described later also realizes a pointing device function in cooperation with the mouse. The display unit 13 is, for example, a monitor, a display, a touch panel, or a speaker, and displays and outputs coverage information generated by the control unit 20 described later.

  The storage unit 15 stores data and programs necessary for various processes performed by the control unit 20, and includes a program DB (DataBase) 16, a framework counter DB 17, and a coverage information DB 18. The program DB 16, the frame counter DB 17, and the coverage information DB 18 are, for example, semiconductor memory elements such as RAM (Random Access Memory), and storage devices such as a hard disk and an optical disk.

  The program DB 16 stores programs for which coverage information is to be calculated, for example, a program received by the communication control I / F unit 11 and a program read from a storage medium by the input unit 12. For example, the program DB 16 stores a source program described in C language as shown in FIG. FIG. 3 is a diagram illustrating an example of information stored in the program DB.

  SampleSource.c which is a source program shown in FIG. 3 reads header files “stdio.h” and “string.h” which are libraries by include, and declares input / output and character string operations. SampleSource.c executes a function using command line arguments. Specifically, SampleSource.c has a functionA1 with the total number of arguments (int argc) and an array of pointers (char * argc []) indicating the argument character strings as arguments and a return value of “0”. Is defined.

  For each program framework, the framework counter DB 17 stores a counter that counts the number of times the framework has been executed. Specifically, the framework counter DB 17 stores a counter that counts the number of executions for each source file name, function name, class name, method name, and line number of the program for which coverage information is to be calculated.

  For example, as shown in FIG. 4, the framework counter DB 17 stores a counter that counts the number of times of execution of the source file “SampleSource.c” and the number of times of execution of each of the “functions function A 1, B 1, C 1”. In addition, the framework counter DB 17 includes the number of executions of each of “line numbers 3, 5, and 11 of the function functionA1”, the number of executions of “line number 2 of the function functionB1”, and A counter for counting the number of executions is stored.

  In this example, when the source file “SampleSource.c” of the program whose coverage information is to be calculated is executed, there are three functions A1, B1, and C1 that should be executed. And in function A1, there are 3 lines to be executed, 3rd, 5th and 11th lines, in function B1, there are 1 line in 2nd line to be executed, and in function C1 There are 2 lines to be executed, 5th and 9th lines. FIG. 4 is a diagram illustrating an example of information stored in the framework counter DB when the program is described in the C language.

  Further, as shown in FIG. 5, the framework counter DB 17 stores a counter that counts the number of executions of the program class “classA” and the counter that counts the number of executions of “method A1 and A2 of class A”. For example, the framework counter DB 17 stores a counter that counts the number of executions of each of “methodA1 line numbers 2 and 4” and a counter that counts the number of executions of “methodA2 line numbers 2 and 12”. To do. Similarly, the framework counter DB 17 counts the number of executions of the class “classB” of the program, the counter that counts the number of executions of “methodB1 of classB”, and the execution of each of “line numbers 4 and 7 of methodB1”. A counter that counts the number of times is stored.

  In this example, when the coverage information calculation target program is executed, there are two classes A and B to be executed, and class A has two methods A1 and A2 to be executed. The method A1 has two lines to be executed, ie, the second and fourth lines, and the method A2 has two lines to be executed, the second and the 12th lines. Class B has one method B1 to be executed, and method B1 has two lines to be executed, a fourth line and a seventh line. FIG. 5 is a diagram illustrating an example of information stored in the framework counter DB when the program is described in Java (registered trademark).

  The coverage information DB 18 stores coverage information calculated by a coverage information calculation unit 24 described later. For example, as illustrated in FIG. 6, the coverage information DB 18 includes “2009/9/30, function A to function C, 25%” or “2009/9 /” as “calculation date, calculation range, coverage value (execution coverage rate)”. “30, all, 50%”. The “calculation date” stored here is the date when the coverage value was calculated, the “calculation range” is the range of the program that calculated the coverage value, and the “coverage value” is the calculated execution Coverage rate. FIG. 6 is a diagram illustrating an example of information stored in the coverage information DB.

  The control unit 20 is, for example, an integrated circuit such as an ASIC (Application Specific Integrated Circuit) or an electronic circuit such as a CPU (Central Processing Unit) or an MPU (Micro Processing Unit). The control unit 20 includes a control program such as an OS (Operating System), a program that defines various processing procedures, and an internal memory for storing necessary data. Furthermore, the control unit 20 includes a framework extraction unit 21, a counter generation unit 22, a number counting unit 23, and a coverage information calculation unit 24, and executes various processes.

  The framework extraction unit 21 extracts a framework of codes included in the coverage information calculation target program. Specifically, when the input of the coverage information calculation start instruction is accepted by the input unit 12, the framework extraction unit 21 reads the calculation target program from the program DB 16, extracts the code included in the program, and outputs the code to the counter generation unit 22. .

  For example, when the program read from the program DB 16 is described in C language, the framework extraction unit 21 extracts function information from the source code “SampleSource.c” of the program as shown in FIG. Subsequently, the framework extraction unit 21 extracts lines in the function in which substantial processing such as calculation and output is performed in the extracted function information. FIG. 7 is a diagram illustrating an example of extracting a framework from source code described in C language.

  In addition, when the program read from the program DB 16 is described in Java (registered trademark), the framework extraction unit 21 performs Java (registered trademark) VM (Java (registered trademark) Virtual Machine) as shown in FIG. ) Class information is extracted from the module configuration information above. Subsequently, the framework extraction unit 21 extracts method information defined in each extracted class information. Then, the framework extraction unit 21 extracts lines in a function in which substantial processing such as calculation and output is performed in each extracted method. FIG. 8 is a diagram illustrating an example of extracting a framework from a source file described in Java (registered trademark).

  The counter generation unit 22 generates a counter that counts the number of times the framework is executed for each framework extracted by the framework extraction unit 21. Specifically, when the framework is extracted from the framework extraction unit 21, the counter generation unit 22 generates a counter for each extracted framework and stores it in the framework counter DB 17 as shown in FIGS. The number counting unit 23 is notified that the counter has been generated.

  For example, when the coverage information calculation target program is described in C language, the counter generation unit 22 generates a counter for each source file name, function, and line in the function extracted by the framework extraction unit 21. To do. The counter generation unit 22 generates a counter for each line in the class, method, and method extracted by the framework extraction unit 21 when the coverage information calculation target program is described in java (registered trademark). To do.

  Then, the counter generation unit 22 associates the framework extracted by the framework extraction unit 21 with the generated counter. For example, the counter generation unit 22 generates a correspondence relationship between the framework and the counter. Then, when the framework is executed, the counter generation unit 22 adds a program that outputs an execution notification indicating information for identifying the executed framework to the number counting unit 23 in the program source code stored in the program DB 16. To do. The program added to the program source code is deleted after coverage information calculation by the coverage information calculation unit 24 described later. Further, the counter generation unit 22 may add the program to a copy of the program source code stored in the program DB 16 and set this as a coverage information calculation target.

  Further, as an example of information for specifying a framework, any information that can generate a correspondence with a counter may be used as long as it is information that can specify a line number or a uniquely assigned ID in the entire program. Further, as an example of a program to be additionally recorded, various notification methods such as inserting a comment sentence and outputting an execution notification can be used.

  The count counting unit 23 executes a program for calculating coverage information, and counts the number of times the framework extracted by the framework extraction unit 21 is executed using the counter for each framework generated by the counter generation unit 22. For example, when notified that the counter is generated from the counter generation unit 22, the number counting unit 23 reads and executes the program from the program DB 16 and monitors the executed program. The number counting unit 23 counts the executed frame using the correspondence between the counter and the frame generated by the counter generating unit 22 and the execution notification received every time the frame is executed. For example, the number counting unit 23 receives an execution notification every time a line in the program is executed, and increments the counter of each executed line, a function including the line, and a source file including the function. Thereafter, when the program ends, the number counting unit 23 notifies the coverage information calculating unit 24 of an end notification.

  Referring to FIG. 5 as an example, for example, when the 12th line of methodA2 is executed, the number counting unit 23 increments the counter of the 12th line of methodA2, further increments the counter of methodA2, Increment the classA counter. Thereafter, for example, when the seventh row of methodB1 is executed, the number counting unit 23 increments the counter of the seventh row of methodB1, further increments the counter of methodB1, and further increments the counter of classB.

  The coverage information calculation unit 24 calculates the execution coverage rate of the program as coverage information from the number of frames extracted by the counter generation unit 22 and the number of executions for each frame counted by the number counting unit 23. The coverage information calculation unit 24 calculates the coverage information when receiving the end of execution of the program from the number counting unit 23.

  For example, when calculating the execution coverage rate with line coverage indicating a line unit, the coverage information calculation unit 24 counts the number of counters for each line stored in the framework counter DB 17 and calculates the number of incremented counters. Count. Subsequently, the coverage information calculation unit 24 divides the number of incremented counters by the total number of counters for each row, and calculates the proportion of the rows actually executed among the rows to be executed. Then, the coverage information calculation unit 24 stores the calculated ratio, the calculated time, and the range of the program to be calculated in the coverage information DB 18 in association with each other.

  As a specific example, it is assumed that the entire program is executed, and among the counters for each frame shown in FIG. In this case, the coverage information calculation unit 24 counts the total number of counters for each row stored in the framework counter DB 17 as “6”, and counts the number of actually executed rows as “3”. Subsequently, the coverage information calculation unit 24 calculates the execution coverage rate (row) of the executed program as “3/6 * 100 = 50%”. Then, the coverage information calculation unit 24 associates the date “2009/10/30” when the execution coverage is calculated, the range “all” executed, and the calculated execution coverage “50%”, and stores them in the coverage information DB 18. To do.

  Further, the case of executing the entire program and calculating the execution coverage rate by method coverage will be described with reference to FIG. Here, it is assumed that the number of executions of the line number = 2, 4 of methodA1 and the line number = 4, 7 of methodB1 shown in FIG. That is, the number of executions of methodA1 and the number of executions of methodB1 are one or more. In this case, the coverage information calculation unit 24 counts the total number of counters for each method stored in the framework counter DB 17 as “3”, and counts the number of actually executed methods as “2”. Subsequently, the coverage information calculation unit 24 calculates the execution coverage rate (row) of the executed program as “2/3 * 100 = 66.66%”. Then, the coverage information calculation unit 24 associates the date “2009/10/30” when the execution coverage is calculated, the execution range “all”, and the calculated method coverage execution coverage “66%” with the coverage information Store in DB18.

  The coverage information calculation unit 24 receives the range received by the framework extraction unit 21 via the input unit 12 for the range in which the program is executed, so that the range of the executed program, that is, the coverage information calculation target range Can be obtained.

[Process flow]
Next, a processing flow in the coverage information calculation apparatus according to the second embodiment will be described with reference to FIG. FIG. 9 is a flowchart illustrating a process flow in the coverage information calculation apparatus according to the second embodiment.

  As shown in FIG. 9, when a coverage information calculation process start instruction is received by the input unit 12 (Yes in step S101), the framework extraction unit 21 of the coverage information calculation apparatus 10 reads a program to be calculated from the program DB 16 (step S101). S102).

  Subsequently, the framework extraction unit 21 analyzes the structure of the read program and extracts codes included in the program, and the counter generation unit 22 performs the number of times the framework is executed for each framework extracted by the framework extraction unit 21. Is generated (step S103).

  Thereafter, the number counting unit 23 executes a program for calculating coverage information (step S104). Then, the number counting unit 23 uses the counter for each frame generated by the counter generating unit 22 to increment the counter of the actually executed frame, and counts the number of executions for each frame (step S105). Note that the number counting unit 23 repeatedly executes step S105 until execution of the program ends (No at step S106).

  When the execution of the program ends (Yes at step S106), the coverage information calculation unit 24 calculates the execution coverage of the program as coverage information from the number of extracted frameworks and the number of executions for each counted framework. (Step S107).

[Effects of Example 2]
As described above, the coverage information calculation apparatus 10 according to the second embodiment counts the number of times of execution for each code framework such as a function using the framework before the program execution, so that it is not necessary to generate an execution log. There is no need to generate the number of executions for each framework from the log. As a result, the coverage information calculation apparatus 10 can efficiently calculate the coverage information regardless of the program for which coverage information is to be calculated. Further, for example, there is no need to provide an area for outputting an execution log in a storage area such as a memory, so that useless use of the storage area can be prevented without pressing the storage area.

  Although the embodiments of the present invention have been described so far, the present invention may be implemented in various different forms other than the embodiments described above. Therefore, different embodiments will be described below.

(Coverage information calculation range)
For example, the coverage information calculation device disclosed in the present application calculates coverage information only within a predetermined range of the program in addition to calculating coverage information for the entire program as described in the first and second embodiments. can do. For example, when the framework extraction unit 21 is to calculate coverage information, the framework extraction unit 21 receives a range specification such as only the function A of the target program or from the function A to the function C via the input unit 12, and the received range. Only the framework is extracted. Then, the framework extraction unit 21 outputs the extracted framework and the specified range to the counter generation unit 22.

  Subsequently, the counter generation unit 22 generates a counter only for the frame extracted by the frame extraction unit 21, and notifies the count counting unit 23 of the completion of the counter generation and the designated range. Thereafter, the number counting unit 23 executes only the designated range, counts the number of times of execution for each framework using the generated counter, and when the execution of the program is completed, the completion and the designated range are determined. The coverage information calculation unit 24 is notified. And the coverage information calculation part 24 calculates coverage information about the designated range. As a result, the coverage information calculation apparatus 10 can efficiently calculate coverage information within a predetermined range of the program.

(Coverage information calculation target program)
Moreover, although the coverage information calculation apparatus which concerns on Example 1 or 2 illustrated the program described in C language or Java (trademark) as a coverage information calculation object program, this application is not limited to this. . For example, the coverage information calculation apparatus can be processed in the same manner as in the first and second embodiments as long as it is a program described in a procedural language. Moreover, the coverage information calculation apparatus disclosed in the present application can extract a framework from not only a source program but also a compiled module, for example.

(Execution count method)
In addition, the coverage information calculation apparatus according to the second embodiment has described the example in which the number of executions for each framework is counted by associating the framework of the program with the counter and receiving information on the executed framework from the program. However, the present application is not limited to this. For example, when the counter for each framework is created from the post-compiler module, the coverage information calculation apparatus associates the post-compiler module with the counter. Then, the coverage information calculation device monitors the executed modules and counts the executed framework. Various techniques other than the technique described in the second embodiment can be used as a technique for detecting the executed framework.

(Coverage information unit)
Further, the coverage information calculation apparatus according to the first and second embodiments has described the example of calculating the execution coverage ratio in the line coverage as the coverage information, that is, the execution coverage ratio indicating how many lines are actually executed. The present application is not limited to this. For example, in addition to the line coverage focusing on the program lines used in the first and second embodiments, the class coverage focusing on the class, the method coverage focusing on the method, the function coverage focusing on the function, etc. in arbitrary units in the code The execution coverage rate can be calculated.

  As an example, the coverage information calculation apparatus can calculate the execution coverage in method coverage from the total number of methods to be executed and the number of methods actually executed. Further, the coverage information calculation apparatus can calculate the execution coverage rate in class coverage from the total number of classes to be executed and the number of classes actually executed.

(System configuration etc.)
In addition, among the processes described in the present embodiment, all or a part of the processes described as being automatically performed can be manually performed. Alternatively, all or part of the processing described as being performed manually can be automatically performed by a known method. In addition, the processing procedures, control procedures, and specific names shown in the above-mentioned documents and drawings, for example, information including various data and parameters shown in FIGS. 3 to 6 are optional unless otherwise specified. Can be changed.

  Further, each component of each illustrated apparatus is functionally conceptual, and does not necessarily need to be physically configured as illustrated. That is, for example, the specific form of distribution / integration of each device such as integration of the framework extraction unit 21 and the counter generation unit 22 is not limited to the illustrated one, and all or a part thereof can be used for various loads and usage conditions. Accordingly, it can be configured to be functionally or physically distributed and integrated in arbitrary units. Further, all or any part of each processing function performed in each device may be realized by a CPU and a program analyzed and executed by the CPU, or may be realized as hardware by wired logic.

(program)
By the way, the various processes described in the above embodiments can be realized by executing a program prepared in advance on a computer system such as a personal computer or a workstation. Therefore, in the following, an example of a computer system that executes a program having the same function as in the above embodiment will be described.

  FIG. 10 is a diagram illustrating an example of a computer system that executes a coverage information calculation program. As illustrated in FIG. 10, the computer system 100 includes a RAM 101, an HDD 102, a ROM 103, and a CPU 104. Here, the ROM 103 stores in advance a program that exhibits the same function as in the above embodiment. That is, as shown in FIG. 10, the ROM 103 stores in advance a framework extraction program 103a, a counter generation program 103b, a number counting program 103c, and a coverage information calculation program 103d.

  Then, the CPU 104 reads out and executes these programs 103a to 103d, thereby forming each process as shown in FIG. That is, each of the programs 103a to 103d is a framework extraction process 104a, a counter generation process 104b, a number counting process 104c, and a coverage information calculation process 104d. Note that the framework extraction process 104a corresponds to the framework extraction unit 21 shown in FIG. 2, and similarly, the counter generation process 104b corresponds to the counter generation unit 22. The number counting process 104c corresponds to the number counting unit 23 shown in FIG. 2, and the coverage information calculation process 104d corresponds to the coverage information calculation unit 24.

  The HDD 102 is provided with a program table 102a, a framework counter table 102b, and a coverage information table 102c. The program table 102a corresponds to the program DB 16 shown in FIG. 2, the framework counter table 102b corresponds to the framework counter DB 17, and the coverage information table 102c corresponds to the coverage information DB 18.

  By the way, the above-described programs 103 a to 103 d are not necessarily stored in the ROM 103. For example, the programs 103a to 103d are stored in a “portable physical medium” such as a flexible disk (FD), a CD-ROM, an MO disk, a DVD disk, a magneto-optical disk, or an IC card inserted into the computer system 100. You may make it leave. Further, it may be stored in a “fixed physical medium” such as a hard disk drive (HDD) provided inside or outside the computer system 100. Further, it may be stored in “another computer system” connected to the computer system 100 via a public line, the Internet, a LAN, a WAN, or the like. Then, the computer system 100 may read the program from these and execute it.

  That is, the program referred to in the other embodiments is recorded in a computer-readable manner on a recording medium such as the above-mentioned “portable physical medium”, “fixed physical medium”, “communication medium”, and the like. . Then, the computer system 100 realizes the same function as the above-described embodiment by reading and executing the program from such a recording medium. The program referred to in the other embodiments is not limited to being executed by the computer system 100. For example, the present invention can be similarly applied to a case where another computer system or server executes a program or a case where these programs cooperate to execute a program.

  The following supplementary notes are further disclosed with respect to the embodiments including the above examples.

(Supplementary Note 1) Using a counter provided for each code framework included in a program for which coverage information is to be calculated, a number counting procedure for counting the number of times the framework is executed when the program is executed;
Coverage information for causing a computer to execute a coverage information calculation procedure for calculating coverage information from the number of frames provided with the counter and the number of frames for which the number of executions has been counted by the number counting procedure. Calculation program.

(Supplementary Note 2) Before executing the program, a framework extraction procedure for extracting a framework of code included in the program;
The coverage information calculation program according to claim 1, further causing a computer to execute a counter generation procedure for generating a counter that counts the number of times the framework has been executed for each framework extracted by the framework extraction procedure. .

(Supplementary Note 3) The coverage information calculation procedure includes a program execution coverage ratio indicating a ratio of the number of frames whose number of executions is counted by the number counting procedure to the number of frames extracted by the framework extraction procedure, The coverage information calculation program according to appendix 2, wherein the coverage information calculation program is calculated as information.

(Supplementary note 4) a counter storage unit that stores a counter for each framework of a code included in a program for which coverage information is to be calculated;
Using a counter for each frame stored in the counter storage unit, the number counting unit that counts the number of times the frame is executed when the program is executed,
A coverage information calculation unit for calculating coverage information from the number of frames provided with a counter stored in the counter storage unit and the number of frames for which the number of executions is counted by the number counting unit. Coverage information calculation device.

(Supplementary Note 5) Before executing the program, a framework extraction unit that extracts a framework of code included in the program;
The coverage information calculation apparatus according to appendix 4, wherein the computer further executes a counter generation unit that generates the counter and stores the counter in the counter storage unit for each frame extracted by the framework extraction unit.

(Supplementary note 6) The coverage information calculation unit calculates an execution coverage rate of a program indicating a ratio of the number of frames whose number of executions is counted by the number counting unit to the number of frames extracted by the framework extraction unit, The coverage information calculation apparatus according to appendix 5, wherein the coverage information calculation apparatus calculates the information.

(Supplementary note 7) Counting step of counting the number of times the framework is executed when the program is executed by using a counter provided for each code framework included in the program for which coverage information is calculated;
A coverage information calculation method comprising: a coverage information calculation step of calculating coverage information from the number of frames provided with the counter and the number of frames for which the number of executions has been counted by the number counting step. .

(Supplementary note 8) Before executing the program, a framework extraction step of extracting a framework of code included in the program;
The coverage information calculation method according to appendix 7, further comprising: causing the computer to further execute a counter generation step for generating the counter for each frame extracted by the framework extraction step.

(Supplementary note 9) The coverage information calculation step includes an execution coverage rate of a program indicating a ratio of the number of frames whose number of executions has been counted by the number-of-times counting step to the number of frames extracted by the framework extraction step. The coverage information calculation method according to appendix 8, wherein the coverage information calculation method is calculated as information.

DESCRIPTION OF SYMBOLS 1 Coverage information calculation apparatus 1a Counting part 1b Coverage information calculation part 2 Program source code 3 Coverage information 10 Coverage information calculation apparatus 11 Communication control I / F part 12 Input part 13 Display part 15 Storage part 16 Program DB
17 Framework counter DB
18 Coverage information DB
20 Control Unit 21 Framework Extraction Unit 22 Counter Generation Unit 23 Number Counting Unit 24 Coverage Information Calculation Unit

Claims (9)

A subroutine contained in the program, for a row included in the subroutine, it is detected whether each said subroutine and the row when running the program is executed,
And total number of pre-Symbol subroutine that is part of the program, based on the number of execution is detected subroutine, and displays information indicating a ratio of the executed subroutine of the overall subroutine contained in said program, run the total number of rows included in the subroutine, on the basis of the number of execution is detected Tagyo displays information indicating a ratio of a line that was executed within the entire row included in the subroutine, the process to the computer then,
The computer
When generating information indicating the ratio of the executed subroutine, the number of subroutines in which execution of any one of the lines included in the subroutine is detected is defined as the number of subroutines in which the execution is detected.
A coverage information generation program characterized by that.   Using the counter corresponding to the subroutine included in the program and the counter corresponding to the line included in the program, the process of counting the number of times the subroutine is executed and the number of times the line is executed The coverage information generation program according to claim 1, further causing the computer to execute the program. Before executing the program, extract the subroutine and the line included in the program,
3. The coverage information generation program according to claim 2, further causing the computer to further execute a process of generating the counter for each of the extracted subroutines and for each row. Execution coverage program indicating the ratio of the number of the subroutine execution is counted among whole the subroutine the extracted, the ratio of the number of Kigyo before execution of entire rows the extracted is counted an execution coverage of the program shown, the coverage information generating program according to claim 3, characterized in that to produce a coverage information.   The coverage information generating program according to claim 1, wherein the detecting process detects whether a function or a method is executed as the subroutine. When any line is executed using a counter corresponding to each hierarchy up to each line to be executed in the function or method in the program, the executed line and the function or method including the line are executed. And for each of the program including the function or method including the line, causing the computer to further execute a process of counting the number of times executed,
The processing to be generated uses the number of each of the function, the method, and the line included in the program, and the number of times each of the function, the method, and the line is executed, and coverage information of the program The coverage information generation program according to claim 5, wherein: When the subroutine or the line included in the subroutine is executed, source code that outputs an execution notification that is information for specifying the executed subroutine or the line is added to the program, and the subroutine executed After the information indicating the ratio and the information indicating the ratio of the executed lines are generated, the computer is further caused to execute a process of deleting the added source code,
The coverage information generating program according to claim 1, wherein the detecting process detects that the subroutine and the line are executed in accordance with the execution notification output by the added source code. . A subroutine contained in the program, for a row included in the subroutine, a detecting unit for detecting whether each said subroutine and the row has been executed when executing the program,
And total number of pre-Symbol subroutine that is part of the program, based on the number of subroutines that have been detected by the detecting unit, and displays information indicating a ratio of the executed subroutine of the overall subroutine contained in said program together, generating unit which displays the total number of rows included in the subroutine, based on the number of Tagyo detected by the detecting unit, information indicating a ratio of a line that was executed within the entire row included in the subroutine It has a door,
When generating the information indicating the ratio of the executed subroutine, the generating unit indicates the number of subroutines in which execution of any one of the lines included in the subroutine is detected, and the subroutine in which the execution is detected. The number of
Coverage information generating apparatus according to claim and this. A subroutine contained in the program, for a row included in the subroutine, it is detected whether each said subroutine and the row when running the program is executed,
And total number of pre-Symbol subroutine that is part of the program, based on the number of execution is detected subroutine, and displays information indicating a ratio of the executed subroutine of the overall subroutine contained in said program, wherein the total number of rows included in the subroutine, on the basis of the number of execution it is detected Tagyo displays information indicating a ratio of a line that was executed within the entire row included in the subroutine, the process
The processing to display is
When generating information indicating the ratio of the executed subroutine, the number of subroutines in which execution of any one of the lines included in the subroutine is detected is defined as the number of subroutines in which the execution is detected.
Coverage information generated wherein a call.

Images