JP2004227105A - Program evaluation method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a program evaluation method facilitating the management of the progress of an object-directed software development by enabling a person to know the present degree of completion thereof. <P>SOLUTION: It is checked for each method of all classes present in a model drawing whether or not each method is mounted in a source file corresponding thereto. When any line other than a comment is not present in each method, it is determined that this method is not mounted. The number of unmounted methods is totaled, and the ratio to the number of all the methods present in the model drawing is calculated and reported to a user. <P>COPYRIGHT: (C)2004,JPO&NCIPI

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a program evaluation method using an object-oriented language.
[0002]
[Prior art]
In recent years, object-oriented software development has been widely practiced from the viewpoint of program reuse. There are also development means for automatically generating a source code from a model diagram (such as UML notation) created in an object-oriented analysis / design stage and using the source code for software development.
[0003]
However, the source code generated using such a source code automatic generation function is mainly a frame part (class declaration, attribute declaration, method arguments and return value, etc.), and the contents of the method are empty. Will remain. (Although there are a few tools that generate the contents of methods.)
[0004]
The problem here is that many empty methods are generated, making it difficult to see the completeness of the actual software. In object-oriented development, a source / header file exists for each class, and the number of files is larger than in the conventional method. Unlike the conventional method, since there is a function for the time being, the fact that no compile error occurs at the caller is also one of the factors that make the degree of completion invisible.
[0005]
2. Description of the Related Art Conventionally, there is a program evaluation method that checks the presence or absence of undefined methods, frames, and slots, and enables evaluation in an unfinished object-oriented program (for example, see Patent Document 1). In this method, for example, when an undefined method is called during the execution of a program, the content to be processed by the method is displayed, and the input of a return value is prompted.
[0006]
[Patent Document 1]
JP-A-5-265804 [0007]
[Problems to be solved by the invention]
However, the conventional invention described in Patent Document 1 can execute program evaluation, but it is difficult for a user to grasp the current degree of perfection of software.
[0008]
The present invention has been made in view of the above circumstances, and it is an object of the present invention to provide a program evaluation method for supporting the grasp of the degree of completion by calculating the ratio of empty methods.
[0009]
Also, in the object orientation, there is a concept of inheritance, and there is a design method in which a method of a super class is intentionally emptied and implemented by a sub class. At this time, even the method that is emptied is counted as unimplemented, and accurate completion cannot be calculated. Therefore, an object of the present invention is to provide a program evaluation method for calculating a degree of completion by regarding a method which is considered to be emptied among the methods of a superclass as being already implemented.
[0010]
In addition, it is necessary not only to know the degree of perfection of the current software, but also to know information on which methods need to be implemented. In an actual software development environment, such information is also effective, and it is possible to grasp which part is delayed. Therefore, an object of the present invention is to provide a program evaluation method for outputting a list of methods that need to be implemented as a list.
[0011]
[Means for Solving the Problems]
In order to achieve the above object, a method for evaluating a program according to claim 1 is an implementation check for checking whether a method is implemented in a corresponding source file for each method of all classes existing in a model diagram. When there is no line other than comment in the actual processing part enclosed in braces for each step and each method, the judgment step to judge that the method is not implemented and the number of unimplemented methods are summed up, The method is characterized in that it has a calculation step of calculating a ratio of the total number of methods existing in the model diagram and a notification step of notifying the user of the calculation result.
[0012]
A program evaluation method according to claim 2, wherein for each method of all classes existing in the model diagram, an implementation check step of checking whether the method is implemented in the corresponding source file, and a curly bracket of each method When there is no line other than the comment in the actual processing part surrounded by, the judgment step to judge that the method is not implemented and the number of unimplemented methods are totaled, and all the methods existing in the model diagram The calculation step of calculating the ratio to the number, the notification step of notifying the user of the calculation result, and whether the method that is supposed to be empty in the superclass, that is, the method to be implemented in the subclass, is a virtual function And a virtual function check step for checking that the method to be implemented in the subclass is a virtual function. If, it is characterized in that considered as already implemented the Messodo.
[0013]
A program evaluation method according to claim 3, wherein for each method of all classes existing in the model diagram, an implementation check step of checking whether the method is implemented in the corresponding source file, and a curly brace of each method When there is no line other than the comment in the actual processing part surrounded by, the judgment step to judge that the method is not implemented and the number of unimplemented methods are totaled, and all the methods existing in the model diagram The calculation step of calculating the ratio to the number, the notification step of notifying the user of the calculation result, and whether the method that is supposed to be empty in the superclass, that is, the method to be implemented in the subclass, is a virtual function In the virtual function check step for checking And a storage step of storing the head name, at the stage of notifying finally complete, stored in the storage step, is characterized by outputting the enumeration method names that must be implemented.
[0014]
According to a fourth aspect of the present invention, in the method of the second aspect, it is determined whether the method to be implemented in the subclass is a virtual function by checking a header file of a class having the method. Features.
[0015]
According to a fifth aspect of the present invention, in the method of the fourth aspect, if a virtual declaration is made in a prototype declaration of a method in a header file, the method becomes a virtual function. .
[0016]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.
[0017]
First, a first embodiment of the present invention will be described. In the first embodiment, the ratio of empty methods is calculated.
[0018]
For each method of all classes existing in the model diagram, check whether the method is implemented in the corresponding source file. If there is no line other than a comment in the part enclosed in {} (actual processing part indicated by braces) of each method, it is determined that the method is not implemented. Total the number of unimplemented methods, calculate the ratio to the total number of methods existing in the model diagram, and notify the user.
[0019]
In the first embodiment, for example, processing is performed according to the flow shown in FIG. First, the user makes a request to calculate the degree of software completion (S101). Here, all methods (A) and unimplemented methods (B) are not counted. Next, the total number of methods is calculated (S102), and it is checked whether there is a source file that has not been searched (S103). If all the source files have been searched (S103 / NO), the search of all the files is terminated (S105), the completion degree is calculated (S108), the completion degree is output, and the result is notified to the user (S110). .
[0020]
If there is an unsearched file (S103 / YES), the method is searched (S104). After the search, it is checked whether or not a line other than the comment exists in the part of the method enclosed in parentheses (S106). If there is a line other than the comment (S106 / YES), it is determined that the method has been implemented, the search of one file is terminated (S109), and it is checked again whether there is an unsearched file (S103). Thereafter, the above processing is repeated until there is no unsearched file.
[0021]
If there is no line other than the comment (S106 / NO), the search method is regarded as not implemented, counted as the number of unimplemented methods, and stored (S107). Then, the search for one file is terminated (S109), and it is again checked whether there is an unsearched file (S103). The above process is repeated, and when all the source files have been searched (S103 / NO), the search of all the files is completed (S105), the completion degree is calculated (S108), the completion degree is output, and the result is notified to the user. (S110).
[0022]
Next, a second embodiment of the present invention will be described. In the second embodiment, the degree of completion is calculated excluding the virtual function.
[0023]
Checks if the method is a virtual function, and if it is a virtual function, considers it implemented. Check if it is a virtual function by looking at the header file of the class that has the method. If a virtual declaration is made in the prototype declaration of the method in the header file, the method becomes a virtual function. The number of methods determined to be unimplemented is totaled, the percentage of the total number of methods existing in the model diagram is calculated, and the user is notified.
[0024]
In the second embodiment, for example, processing is performed according to the flow shown in FIG. First, similarly to the first embodiment, the user makes a request for calculating the degree of software completion (S201). Here, all methods (A) and unimplemented methods (B) are not counted. Next, the number of all methods is calculated (S202), and it is checked whether there is a source file that has not been searched (S203). If all the source files have been searched (S203 / NO), the search of all the files is terminated (S205), the completion degree is calculated (S208), the completion degree is output, and the result is notified to the user (S210). .
[0025]
If there is an unsearched file (S203 / YES), the method is searched (S204). After the search, it is checked whether a line other than the comment exists in the part of the method enclosed in parentheses (S206). If there is a line other than a comment (S206 / YES), it is determined that the method has been implemented, the search of one file is terminated (S212), and it is checked again whether there is an unsearched file (S203). Thereafter, the above processing is repeated until there is no unsearched file.
[0026]
If there is no line other than the comment (S206 / NO), the header file is searched for the method being checked (S207). Then, it is checked whether the method under check is a virtual function (S209). If it is a virtual function (S209 / YES), the search for one file is terminated (S212), and it is checked again whether there is an unsearched file (S203).
[0027]
If it is not a virtual function (S209 / NO), the search method is regarded as not implemented, and is counted and stored as the number of unimplemented methods (S211). Then, the search for one file is terminated (S212), and it is again checked whether there is any unsearched file (S203). The above processing is repeated, and when all the source files have been searched (S203 / NO), the search of all the files is terminated (S205), the completion degree is calculated (S208), the completion degree is output, and the result is notified to the user. (S210).
[0028]
Next, a third embodiment of the present invention will be described. In the third embodiment, a method name that needs to be implemented is output.
[0029]
In the third embodiment, in the process flow of the first and second embodiments, in the process of calculating the current completion degree, the method name counted as not implemented is stored, and finally the completion degree is calculated. At the notification stage, the stored method names are listed and output.
[0030]
In the third embodiment, for example, processing is performed according to the flow shown in FIG. First, as in the first and second embodiments, the user makes a request to calculate the degree of software completion (S301). Here, all methods (A) and unimplemented methods (B) are not counted. Next, the total number of methods is calculated (S302), and it is checked whether there is a source file that has not been searched (S303). If all the source files have been searched (S303 / NO), the search of all the files is completed (S305), the completion degree is calculated (S308), the completion degree is output, and the result is notified to the user (S310). .
[0031]
If there is an unsearched file (S303 / YES), the method is searched (S304). After the search, it is checked whether a line other than the comment exists in the part of the method enclosed in parentheses (S306). If there is a line other than the comment (S306 / YES), it is determined that the method has been implemented, the search of one file is terminated (S312), and it is checked again whether there is an unsearched file (S303). Thereafter, the above processing is repeated until there is no unsearched file.
[0032]
If there is no line other than the comment (S306 / NO), a method being checked is searched from the header file (S307). Then, it is checked whether the method under check is a virtual function (S309). If it is a virtual function (S309 / YES), the search of one file is terminated (S312), and it is checked again whether there is an unsearched file (S303).
[0033]
If it is not a virtual function (S309 / NO), the search method is regarded as unimplemented, counted and stored as the number of unimplemented methods, and the name of the method being checked is added to the storage unit (S311). Then, the search for one file is terminated (S212), and it is checked again whether there is an unsearched file (S303). The above processing is repeated, and when all the source files have been searched (S303 / NO), the search of all files is terminated (S305), the completion degree is calculated (S308), and the completion degree and the stored unimplemented method are stored. The names are listed and output, and the result is notified to the user (S310).
[0034]
【The invention's effect】
As is apparent from the above description, according to the first aspect of the present invention, for each method of all the classes existing in the model diagram, it is checked whether the method is implemented in the corresponding source file, In each method, if there is no line other than comment in the actual processing part enclosed by curly braces, it is determined that the method is not implemented, the number of unimplemented methods is totaled, and the Calculates the ratio to the total number of existing methods and notifies the user, so even if there are many unimplemented methods that are common in object-oriented software development, it is possible to know the current degree of completion. It is easy to manage the progress.
[0035]
According to the second aspect of the present invention, it is checked whether a method considered to be empty in the superclass, that is, a method to be implemented in the subclass is a virtual function. Since it is characterized by that it can be calculated, it is possible to calculate the degree of perfection more accurately.
[0036]
According to the third aspect of the present invention, in the process of calculating the current degree of completion, the method name counted as not implemented is stored, and the stored method name is finally notified at the stage of notifying the degree of completion. Is enumerated and output, so the methods that need to be implemented in the future are clarified, and it is easy to manage not only the project level but also the progress of each charge level.
[0037]
According to the invention described in claim 4, in the invention described in claim 2, whether a method to be implemented in the subclass is a virtual function is checked by looking at a header file of a class having the method. Therefore, it is possible to consider that the method that is emptied in the super class is already implemented, and it is possible to calculate the completeness more accurately.
[0038]
According to the invention described in claim 5, in the invention described in claim 4, the method becomes a virtual function if the virtual declaration is made in the prototype declaration of the method in the header file. The methods that are emptied by the superclass can be regarded as implemented, and the degree of completion can be calculated more accurately.
[Brief description of the drawings]
FIG. 1 is a flowchart illustrating a processing operation according to a first embodiment of the present invention.
FIG. 2 is a flowchart illustrating a processing operation according to a second embodiment of the present invention.
FIG. 3 is a flowchart illustrating a processing operation according to a third embodiment of the present invention.

Claims (5)

For each method of all classes existing in the model diagram, an implementation check step for checking whether the method is implemented in the corresponding source file,
When there is no line other than a comment in the actual processing part of each method, a determining step of determining that the method is not implemented,
A calculation step of summing the number of unimplemented methods and calculating a ratio with the total number of methods existing in the model diagram,
A notification step of notifying a user of the calculation result,
A program evaluation method comprising: For each method of all classes existing in the model diagram, an implementation check step for checking whether the method is implemented in the corresponding source file,
When there is no line other than a comment in the actual processing part of each method, a determining step of determining that the method is not implemented,
A calculation step of summing the number of unimplemented methods and calculating a ratio with the total number of methods existing in the model diagram,
A notification step of notifying a user of the calculation result,
A virtual function check step for checking whether a method considered to be empty in the superclass, that is, a method to be implemented in the subclass, is a virtual function;
If the method to be implemented in the subclass is a virtual function, the method is regarded as implemented, and the method is evaluated. For each method of all classes existing in the model diagram, an implementation check step for checking whether the method is implemented in the corresponding source file,
When there is no line other than a comment in the actual processing part of each method, a determining step of determining that the method is not implemented,
A calculation step of summing the number of unimplemented methods and calculating a ratio with the total number of methods existing in the model diagram,
A notification step of notifying a user of the calculation result,
A virtual function check step to check whether the method that is supposed to be empty in the superclass, that is, the method to be implemented in the subclass, is a virtual function,
In the process of calculating the current perfection, has a storage step of storing the method name counted as not implemented,
A method for evaluating a program, comprising: enumerating and outputting the names of the methods that need to be implemented and stored in the storage step at the stage of finally notifying the completion degree. 3. The program evaluation method according to claim 2, wherein whether the method to be implemented in the subclass is a virtual function is checked by looking at a header file of the class having the method. 5. The program evaluation method according to claim 4, wherein the method becomes a virtual function if a virtual declaration is made in a prototype declaration of the method in the header file.

Images