CN115292162A - Report generation method, report generation device, report generation apparatus, report generation medium, and program product - Google Patents

Abstract

Embodiments of the present disclosure disclose report generation methods, apparatuses, devices, media, and program products. A specific implementation of the method includes: generating a coverage information text according to a code execution situation file for a target source file, wherein the target source file is a source file of the target version; determining a set of changed code line information, wherein the change The changed code line information in the code line information set represents the location information of the code difference between the target source file and the historical source file, wherein the version corresponding to the historical source file is earlier than the target version; according to the coverage information text, the target text is generated , wherein the target text represents the coverage information of the changed code line information set; and according to the target text, an incremental code coverage report for the target source file is generated. This embodiment can accurately generate incremental code coverage reports for target source files.

Description

Report generating method, device, device, medium and program product

technical field

The embodiments of the present disclosure relate to the field of computer technology, and specifically relate to a report generating method, device, device, medium and program product.

Background technique

At present, in the research and development process, testers often use normalized functional testing, boundary testing, regression testing and other methods based on personal experience and understanding of business requirements to ensure the testing quality of each incremental code. For the generation of the incremental code coverage report, the usual method is: first, the relevant testers count the incremental code information. Then, an incremental code coverage report is generated based on the incremental code information.

However, the inventors have found that when the incremental code coverage report is generated in the above manner, the following technical problems often exist:

Incremental code information is often intricate, and the amount of code is often relatively large. During the statistical process, relevant testers may omit or add more codes, resulting in inaccurate incremental code coverage reports generated subsequently.

The above information disclosed in this Background section is only for enhancement of understanding of the background of the inventive concept and therefore it may contain information that does not form the prior art that is already known in this country to a person of ordinary skill in the art.

Contents of the invention

The Summary of the Disclosure is provided to introduce concepts in a simplified form that are described in detail in the Detailed Description that follows. The content of this disclosure is not intended to identify the key features or essential features of the claimed technical solution, nor is it intended to be used to limit the scope of the claimed technical solution.

Some embodiments of the present disclosure propose a report generation method, device, device, medium, and program product to solve the technical problems mentioned in the background art section above.

In a first aspect, some embodiments of the present disclosure provide a method for generating a report, including: generating coverage information text according to a code execution status file for a target source file, wherein the above target source file is a source file of a target version; Determine the changed code line information set, wherein the changed code line information in the above changed code line information set represents the location information of the code difference between the above target source file and the historical source file, wherein the version corresponding to the above historical source file is earlier than the above target version ; According to the above-mentioned coverage information text, generate target text, wherein, the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set; according to the above-mentioned target text, generate an incremental code coverage report for the above-mentioned target source file.

Optionally, the above method further includes: in response to receiving the report display request, sending the above incremental code coverage report to the report query display terminal.

Optionally, the above method further includes: adjusting the test case corresponding to the above target source file according to the above incremental code coverage report.

Optionally, the changed code line information in the changed code line information set includes: the file name of the code transformed file and the changed code line.

Optionally, generating the target text according to the above-mentioned coverage information text includes: determining at least one changed file name for the above-mentioned historical source file in the above-mentioned target source file; according to the above-mentioned at least one changed file name and the above-mentioned coverage information Text, generating a change text, wherein the text content of the change text is the content associated with the at least one change file name in the coverage information text content, and the coverage information text content is the text content of the coverage information text ; Generating the above target text according to the above-mentioned change text, the change code line and the file name included in the change code line information in the above-mentioned change code line information set.

Optionally, the above-mentioned determination of at least one changed file name for the above-mentioned historical source file in the above-mentioned target source file includes: determining code branch information and code submission records according to the above-mentioned code execution file; according to the above-mentioned code branch information and code Commit a record, generating at least one of the above changetext names.

In the second aspect, some embodiments of the present disclosure provide a report generating device, including: a first generating unit configured to generate coverage information text according to the code execution status file for the target source file, wherein the target source The file is the source file of the target version; the determining unit is configured to determine the changed code line information set, wherein the changed code line information in the above-mentioned changed code line information set represents the position information of the code difference between the above-mentioned target source file and the historical source file, Wherein, the version corresponding to the above-mentioned historical source file is earlier than the above-mentioned target version; the second generation unit is configured to generate the target text according to the above-mentioned coverage information text, wherein the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set ; The third generating unit is configured to generate an incremental code coverage report for the target source file according to the target text.

Optionally, the above apparatus further includes: in response to receiving the report display request, sending the above incremental code coverage report to the report query display terminal.

Optionally, the above device further includes: adjusting the test case corresponding to the above target source file according to the above incremental code coverage report.

Optionally, the changed code line information in the above changed code line information set includes: the file name and the changed code line of the file for code transformation.

Optionally, the second generation unit may be further configured to: determine at least one changed file name for the historical source file in the target source file; generate the changed file according to the at least one changed file name and the coverage information text Text, wherein, the text content of the above-mentioned change text is the content associated with the above-mentioned at least one changed file name in the coverage information text content, and the above-mentioned coverage information text content is the text content of the above-mentioned coverage information text; according to the above-mentioned change Text, the changed code line and the file name included in the changed code line information in the above changed code line information set, and generate the above target text.

Optionally, the second generating unit may be further configured to: determine code branch information and code submission records according to the above code execution situation file; generate the above at least one change text name according to the above code branch information and code submission records.

In a third aspect, some embodiments of the present disclosure provide an electronic device, including: one or more processors; The processor executes, so that one or more processors implement the method described in any implementation manner of the first aspect.

In a fourth aspect, some embodiments of the present disclosure provide a computer-readable medium on which a computer program is stored, wherein, when the program is executed by a processor, the method described in any implementation manner in the first aspect is implemented.

In a fifth aspect, some embodiments of the present disclosure provide a computer program product, including a computer program. When the computer program is executed by a processor, the method described in any implementation manner in the above first aspect is implemented.

The above-mentioned various embodiments of the present disclosure have the following beneficial effects: the incremental code coverage report for the target source file can be accurately generated through the report generation method of some embodiments of the present disclosure. Specifically, the reason why the incremental code coverage report is not accurate is that the incremental code information is often intricate and the code volume is often relatively large. During the statistical process, relevant testers may omit or add more codes, resulting in inaccurate incremental code coverage reports generated subsequently. Based on this, in the report generation method of some embodiments of the present disclosure, first, according to the code execution status file for the target source file, the coverage information text is generated for subsequent generation of the target representing the coverage information of the changed code line information set text. Next, the changed code line information set is determined for subsequent generation of target text corresponding to the changed code line information set. Furthermore, according to the above coverage information text, the target text is generated accurately and efficiently. Wherein, the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set. Finally, based on the above target text, an incremental code coverage report for the above target source files can be generated accurately and efficiently.

Description of drawings

The above and other features, advantages and aspects of the various embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic and elements and elements have not necessarily been drawn to scale.

FIG. 1 is a schematic diagram of an application scenario of a report generating method according to some embodiments of the present disclosure;

Figure 2 is a flow diagram of some embodiments of a report generation method according to the present disclosure;

FIG. 3 is a flow chart of other embodiments of a report generating method according to the present disclosure;

4 is a schematic diagram of the operation of the report query display terminal in some embodiments of the report generation method according to the present disclosure;

Fig. 5 is a schematic structural diagram of some embodiments of a report generation device according to the present disclosure;

FIG. 6 is a schematic structural diagram of an electronic device suitable for implementing some embodiments of the present disclosure.

Detailed ways

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the disclosure are shown in the drawings, it should be understood that the disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these examples are provided so that the understanding of this disclosure will be thorough and complete. It should be understood that the drawings and embodiments of the present disclosure are for exemplary purposes only, and are not intended to limit the protection scope of the present disclosure.

It should also be noted that, for the convenience of description, only the parts related to the related invention are shown in the drawings. In the case of no conflict, the embodiments in the present disclosure and the features in the embodiments can be combined with each other.

It should be noted that concepts such as "first" and "second" mentioned in this disclosure are only used to distinguish different devices, modules or units, and are not used to limit the sequence of functions performed by these devices, modules or units or interdependence.

It should be noted that the modifications of "one" and "multiple" mentioned in the present disclosure are illustrative and not restrictive, and those skilled in the art should understand that unless the context clearly indicates otherwise, it should be understood as "one or more" multiple".

The names of messages or information exchanged between multiple devices in the embodiments of the present disclosure are used for illustrative purposes only, and are not used to limit the scope of these messages or information.

The present disclosure will be described in detail below with reference to the accompanying drawings and embodiments.

Fig. 1 is a schematic diagram of an application scenario of a method for generating a report according to some embodiments of the present disclosure.

In the application scenario of FIG. 1 , first, the electronic device 101 may generate the coverage information text 104 according to the code execution situation file 103 for the target source file 102 . Wherein, the target source file 102 is the source file of the target version 105 . In this application scenario, the target version 105 may be "2.1.3". The electronic device 101 may then determine the change code line information set 108 . Wherein, the changed code line information in the changed code line information set 108 represents the location information of the code difference between the target source file 102 and the historical source file 106 . Wherein, the version 107 corresponding to the historical source file 106 is earlier than the target version 105 . In this application scenario, the version 107 corresponding to the historical source file 106 may be "2.1.2". The changed code line information set 108 may include: "line 23 of the first file" and "line 4 of the second file". Further, the electronic device 101 may generate the target text 109 according to the above coverage information text 104 . Wherein, the target text 109 represents the coverage information of the changed code line information set 108 . Finally, the electronic device 101 can generate an incremental code coverage report 110 for the target source file 102 according to the target text 109 .

It should be noted that the above-mentioned electronic device 101 may be hardware or software. When the electronic device is hardware, it can be realized as a distributed cluster composed of multiple servers or terminal devices, or as a single server or a single terminal device. When an electronic device is embodied as software, it can be installed in the hardware devices listed above. It can be implemented, for example, as a plurality of software or software modules for providing distributed services, or as a single software or software module. No specific limitation is made here.

It should be understood that the number of electronic devices in FIG. 1 is merely illustrative. There may be any number of electronic devices depending on implementation needs.

Continuing to refer to FIG. 2 , a flow 200 of some embodiments of a report generation method according to the present disclosure is shown. The method for generating the report includes the following steps:

Step 201, generate coverage information text according to the code execution situation file for the target source file.

In some embodiments, the execution subject of the above report generation method (for example, the electronic device 101 shown in FIG. 1 ) may generate the coverage information text according to the code execution status file for the target source file. Wherein, the above target source file is the source file of the target version. The aforementioned target source file may be a source file for the target project. For example, the target item may be a face recognition item. The aforementioned target source file may be the source file corresponding to the latest version among the two source files during the incremental code determination process. The code execution status file of the target source file may be a gcda file of the target source file. Wherein, the gcda file may be a file generated by running a compiled source file with compilation parameters added. For example, the compile parameter could be "-fprofile-arcs". The gcda file can include information such as the number of arc jumps. Coverage information text can be full info text. The above-mentioned full info file can represent the coverage information of all codes in the target source file.

It should be noted that the above-mentioned target source files are files obtained with the permission of relevant development users. And by setting options, to determine whether to allow the use of target source files. The above selection items include: options that are allowed to be obtained and options that are not allowed to be obtained.

As an example, the above execution subject may use a code coverage tool (LOCV) to generate the coverage information text according to the code execution status file and the gcno file for the target source file. Among them, the above gcno file can be generated by -ftest-coverage. And the above-mentioned gcno file may include: the information of reconstructing the basic block graph and the line number of the corresponding source code.

As yet another example, the above-mentioned execution subject can use code coverage by using various parameter information and operating environment information obtained from the corresponding database of the server and subsequently used to generate the coverage information text according to the code execution status file for the target source file coverage tool to generate coverage infotext.

Optionally, before step 201, the steps also include:

The aforementioned execution subject may use a pre-packaged coverage information processing software package (SDK, Software Development Kit) to obtain the aforementioned code execution status file. Wherein, the above-mentioned coverage information processing software package can realize functions such as collection, generation, reporting, cleaning, and reset of coverage execution results.

Step 202, determine the changed code line information set.

In some embodiments, the above-mentioned execution subject may determine the change code line information set. Wherein, the changed code line information in the changed code line information set represents position information of code differences between the target source file and the historical source file. Wherein, the version corresponding to the above-mentioned historical source file is earlier than the above-mentioned target version. For example, the version corresponding to the historical source file is "1.3.2". The target version is "1.3.3". The above location information may be code line numbers of difference codes between the target source file and the historical source file. The code line number is the line number of the code line in the corresponding code file. For example, the code line number is "148".

As an example, the above execution subject can use the git diff command to determine the information set of the changed code line.

In some optional implementation manners of some embodiments, the changed code line information in the above changed code line information set includes: the file name of the code transformed file and the changed code line.

Optionally, the changed code line information may be information in the form of key-value pairs. The key in the changed code line information is the file name of the code transformed file, and the value in the changed code line information is the changed code line.

Step 203, generate target text according to the above coverage information text.

In some embodiments, the execution subject may generate the target text according to the coverage information text. Wherein, the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set.

As an example, the above execution subject may generate the target text according to the above coverage information text, including the following steps:

In the first step, the above execution subject can use the git diff command to determine the file name corresponding to each changed code line information in the changed code line information set, and obtain the file name set.

In the second step, the above-mentioned execution subject can filter out the text content corresponding to the file name set from the coverage information text to generate the above-mentioned target text.

In some optional implementations of some embodiments, generating the target text according to the above-mentioned coverage information text may include the following steps:

In the first step, the execution subject may determine at least one changed file name for the historical source file in the target source file. Wherein, the changed file name may be the name of a file whose file naming has changed between the target source file and the historical source file.

As an example, the above execution subject may use the "git diff-name-only" command to determine at least one changed file name.

In the second step, the execution subject may generate a change text according to the at least one change file name and the coverage information text. Wherein, the text content of the above-mentioned change text is the content associated with the above-mentioned at least one change file name in the text content of the coverage information. The above-mentioned coverage information text content is the text content of the above-mentioned coverage information text.

As an example, the execution subject may filter out the text content associated with at least one changed file name from the coverage information text corresponding to the coverage information text, so as to generate the change text.

In the third step, the execution subject may generate the target text according to the changed text, the changed code line and the file name included in the changed code line information in the changed code line information set.

As an example, first, the execution subject may determine the file name corresponding to the changed text as the target file name to obtain a target file name set. Then, the execution subject may determine the file name set corresponding to the changed code line information set. Next, the execution subject may determine the intersection between the file name set and the target file name set to obtain the intersecting file name set. Finally, the text content corresponding to the above intersecting file name set is filtered out from the changed text to generate the target text.

Optionally, the above-mentioned determination of at least one changed file name for the above-mentioned historical source file in the above-mentioned target source file may include the following steps:

In the first step, the above-mentioned execution subject can determine code branch information and code submission records according to the above-mentioned code execution status file.

Wherein, the code branch information may be the code branch of the target source file. The above code submission record may be a submission record for each version of the source file of the target project.

As an example, the execution subject may determine the code branch information and code submission record corresponding to the code execution status file from the database by means of information matching.

In the second step, the above-mentioned execution subject may generate the above-mentioned at least one change text name according to the above-mentioned code branch information and the code submission record.

As an example, the above execution subject may use the git diff command to generate the above at least one change text name according to the above code branch information and code submission records.

Step 204: Generate an incremental code coverage report for the target source file according to the target text.

In some embodiments, the execution subject may generate an incremental code coverage report for the target source file according to the target text. Among them, the incremental code coverage report may include: the coverage information corresponding to the incremental code, the maximum coverage gap corresponding to the incremental code file set, the minimum coverage rate corresponding to the incremental code file set, and the corresponding Maximum coverage. Wherein, the incremental code file set may be each file to which the incremental code belongs. According to the incremental code file set, the incremental code can be divided into a plurality of incremental subcodes. Wherein, the incremental subcodes in the plurality of incremental subcodes are in one-to-one correspondence with the incremental code files in the incremental code file set. Thus, the execution subject can determine the coverage sub-information corresponding to each incremental sub-code. The maximum coverage drop may be a difference between the maximum coverage sub-information and the minimum coverage sub-information in the coverage sub-information set. Wherein, the coverage sub-information in the coverage sub-information set is in one-to-one correspondence with the increment sub-codes in the multiple increment sub-codes.

As an example, the execution subject may use a code coverage tool (LOCV) according to the target text to generate an incremental code coverage report for the target source file.

In some optional implementations of some embodiments, after step 204, the steps further include:

The execution subject may adjust the test case corresponding to the target source file according to the incremental code coverage report.

As an example, the execution subject may receive the use case improvement information associated with the incremental code coverage report, and adjust the test case corresponding to the target source file. Wherein, the above use case improvement information may be information written by the target user according to the incremental code coverage report.

The above-mentioned various embodiments of the present disclosure have the following beneficial effects: the incremental code coverage report for the target source file can be accurately generated through the report generation method of some embodiments of the present disclosure. Specifically, the reason why the incremental code coverage report is not accurate is that the incremental code information is often intricate and the code volume is often relatively large. During the statistical process, relevant testers may omit or add more codes, resulting in inaccurate incremental code coverage reports generated subsequently. Based on this, in the report generation method of some embodiments of the present disclosure, first, according to the code execution status file for the target source file, the coverage information text is generated for subsequent generation of the target representing the coverage information of the changed code line information set text. Next, the changed code line information set is determined for subsequent generation of target text corresponding to the changed code line information set. Furthermore, according to the above coverage information text, the target text is generated accurately and efficiently. Wherein, the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set. Finally, based on the above target text, an incremental code coverage report for the above target source files can be generated accurately and efficiently.

Further referring to FIG. 3 , a flow 300 of another embodiment of the report generation method according to the present disclosure is shown. The method for generating the report includes the following steps:

Step 301, generating coverage information text according to the code execution situation file for the target source file.

Step 302, determine the changed code line information set.

Step 303, generating target text according to the above coverage information text.

Step 304: Generate an incremental code coverage report for the target source file according to the target text.

In some embodiments, for the specific implementation of steps 301-304 and the technical effects brought about by them, reference may be made to steps 201-204 in the embodiment corresponding to FIG. 2 , which will not be repeated here.

Step 305, in response to receiving the report display request, send the incremental code coverage report to the report query display terminal.

In some embodiments, in response to receiving the report display request, the execution subject (such as the electronic device 101 shown in FIG. 1 ) may send the above incremental code coverage report to the report query display terminal. Wherein, the report display request may be a request triggered by a user. A report display request is a request to display an incremental code coverage report. The above report query display terminal may be a terminal that supports functions such as displaying incremental code coverage reports and querying incremental code coverage reports.

As an example, as shown in FIG. 4 , the initial interface of the report query display terminal provides optional options of "report query" and "report creation". When the user clicks the "report query" option, the report query display terminal will jump to the task ID (Identity Document) input page. Wherein, the task ID is the task identifier of the generation task of the incremental code coverage report. By entering the task ID, the report query display terminal can display the incremental code coverage report corresponding to the task ID in real time. Similarly, when the user clicks the "report creation" option, the report query display terminal will jump to the source file upload page. There is a "click to upload file" button that users can click on the report query display terminal to support users to upload the corresponding source files. When the report query display terminal receives the source file uploaded by the user, it will generate the incremental code coverage report corresponding to the source file uploaded by the user in the jump interface, and generate the corresponding task ID. In addition, the incremental code coverage report corresponding to the uploaded source file can be downloaded by the user clicking the "Download" button in the report query display terminal.

It can be seen from FIG. 3 that, compared with the description of some embodiments corresponding to FIG. 2 , the process 300 of the report generation method in some embodiments corresponding to FIG. 3 sends the incremental code coverage report to Report query display terminal. Therefore, the solutions described in these embodiments realize the visualization of the incremental code coverage report through the report query display terminal, and can clearly and intuitively display the coverage of the incremental code to the user, which is convenient for subsequent users to test the target source file. Make adjustments.

Further referring to FIG. 5 , as an implementation of the methods shown in the above figures, the present disclosure provides some embodiments of a report generating device, and these device embodiments correspond to those method embodiments shown in FIG. 2 , and the device specifically It can be applied to various electronic devices.

As shown in FIG. 5 , a report generating apparatus 500 includes: a first generating unit 501 , a determining unit 502 , a second generating unit 503 and a third generating unit 504 . Wherein, the first generating unit 501 is configured to generate the coverage information text according to the code execution status file for the target source file, wherein the target source file is the source file of the target version; the determining unit 502 is configured to determine the changed The code line information set, wherein the changed code line information in the above changed code line information set represents the location information of the code difference between the above target source file and the historical source file, wherein the version corresponding to the above historical source file is earlier than the above target version; The second generation unit 503 is configured to generate the target text according to the above-mentioned coverage information text, wherein the above-mentioned target text represents the coverage information of the above-mentioned changed code line information set; the third generation unit 504 is configured to, according to the above-mentioned target text, Generate an incremental code coverage report for the above target source files.

In some optional implementation manners of some embodiments, the foregoing apparatus 500 further includes: a sending unit (not shown in the figure). Wherein, the sending unit may be configured to: send the incremental code coverage report to the report query display terminal in response to receiving the report display request.

In some optional implementation manners of some embodiments, the changed code line information in the above changed code line information set includes: the file name of the code transformed file and the changed code line.

In some optional implementation manners of some embodiments, the foregoing apparatus 500 further includes: an adjustment unit (not shown in the figure). Wherein, the above adjustment unit may be configured to: adjust the test case corresponding to the above target source file according to the above incremental code coverage report.

In some optional implementations of some embodiments, the second generation unit 503 in the above-mentioned apparatus 500 may be further configured to: determine at least one changed file name for the above-mentioned historical source file in the above-mentioned target source file; The above-mentioned at least one change file name and the above-mentioned coverage information text generate a change text, wherein the text content of the above-mentioned change text is the content associated with the above-mentioned at least one change file name in the coverage information text content, and the above-mentioned coverage information The text content is the text content of the above-mentioned coverage information text; the above-mentioned target text is generated according to the above-mentioned changed text, the changed code line and the file name included in the changed code line information in the above-mentioned changed code line information set.

In some optional implementations of some embodiments, the second generating unit 503 in the above-mentioned apparatus 500 may be further configured to: determine code branch information and code submission records according to the above-mentioned code execution situation file; and code commit records, generating at least one of the above changetext names.

It can be understood that the units recorded in the device 500 correspond to the steps in the method described with reference to FIG. 2 . Therefore, the operations, features and beneficial effects described above for the method are also applicable to the device 500 and the units contained therein, and will not be repeated here.

Referring now to FIG. 6 , it shows a schematic structural diagram of an electronic device (such as the electronic device 101 in FIG. 1 ) 600 suitable for implementing some embodiments of the present disclosure. The electronic device shown in FIG. 6 is only an example, and should not limit the functions and scope of use of the embodiments of the present disclosure.

As shown in FIG. 6, an electronic device 600 may include a processing device (such as a central processing unit, a graphics processing unit, etc.) 601, which may be randomly accessed according to a program stored in a read-only memory (ROM) 602 or loaded from a storage device 608. Various appropriate actions and processes are executed by programs in the memory (RAM) 603 . In the RAM 603, various programs and data necessary for the operation of the electronic device 600 are also stored. The processing device 601 , ROM 602 and RAM 603 are connected to each other through a bus 604 . An input/output (I/O) interface 605 is also connected to the bus 604 .

Typically, the following devices can be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; including, for example, a liquid crystal display (LCD), speaker, vibration an output device 607 such as a computer; a storage device 608 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While FIG. 6 shows electronic device 600 having various means, it should be understood that implementing or having all of the means shown is not a requirement. More or fewer means may alternatively be implemented or provided. Each block shown in FIG. 6 may represent one device, or may represent multiple devices as required.

In particular, according to some embodiments of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, some embodiments of the present disclosure include a computer program product, which includes a computer program carried on a computer-readable medium, where the computer program includes program codes for executing the methods shown in the flowcharts. In some such embodiments, the computer program may be downloaded and installed from a network via communication means 609 , or from storage means 608 , or from ROM 602 . When the computer program is executed by the processing device 601, the above functions defined in the methods of some embodiments of the present disclosure are performed.

It should be noted that the above-mentioned computer-readable medium in some embodiments of the present disclosure may be a computer-readable signal medium or a computer-readable storage medium, or any combination of the above two. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In some embodiments of the present disclosure, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In some embodiments of the present disclosure, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code thereon. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can transmit, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted by any appropriate medium, including but not limited to wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

In some embodiments, the client and the server can communicate using any currently known or future-developed network protocols such as HTTP (HyperText Transfer Protocol, Hypertext Transfer Protocol), and can communicate with digital data in any form or medium (eg, communication network) interconnections. Examples of communication networks include local area networks ("LANs"), wide area networks ("WANs"), internetworks (e.g., the Internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed network of.

The above-mentioned computer-readable medium may be included in the above-mentioned electronic device, or may exist independently without being incorporated into the electronic device. The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by the electronic device, the electronic device: generates the coverage information text according to the code execution status file for the target source file, wherein , the above-mentioned target source file is the source file of the target version; determine the changed code line information set, wherein the changed code line information in the above-mentioned changed code line information set represents the location information of the code difference between the above-mentioned target source file and the historical source file, wherein, The version corresponding to the above historical source file is earlier than the above target version; according to the above coverage information text, generate the target text, wherein the above target text represents the coverage information of the above changed code line information set; according to the above target text, generate the above target text Incremental code coverage report for source files.

Computer program code for carrying out operations of some embodiments of the present disclosure may be written in one or more programming languages, or combinations thereof, including object-oriented programming languages—such as Java, Smalltalk, C++, Also included are conventional procedural programming languages - such as the "C" language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (for example, using an Internet service provider to connected via the Internet).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code that contains one or more logical functions for implementing specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified functions or operations , or may be implemented by a combination of dedicated hardware and computer instructions.

The units described in some embodiments of the present disclosure may be realized by software or by hardware. The described units may also be set in a processor. For example, it may be described as: a processor includes a first generating unit, a determining unit, a second generating unit, and a third generating unit. Wherein, the names of these units do not constitute a limitation on the unit itself under certain circumstances. For example, the first generation unit can also be described as “generate the coverage information text according to the code execution status file for the target source file. unit".

The functions described herein above may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logical device (CPLD) and so on.

Some embodiments of the present disclosure also provide a computer program product, including a computer program, and when the computer program is executed by a processor, any one of the above report generation methods is implemented.

The above descriptions are only some preferred embodiments of the present disclosure and illustrations of the applied technical principles. Those skilled in the art should understand that the scope of the invention involved in the embodiments of the present disclosure is not limited to the technical solution formed by the specific combination of the above-mentioned technical features, but also covers the above-mentioned invention without departing from the above-mentioned inventive concept. Other technical solutions formed by any combination of technical features or equivalent features. For example, a technical solution formed by replacing the above-mentioned features with technical features having similar functions disclosed in (but not limited to) the embodiments of the present disclosure.

Claims (10)

1. A report generation method, comprising:

generating a coverage rate information text according to a code execution condition file aiming at a target source file, wherein the target source file is a source file of a target version;

determining a change code line information set, wherein the change code line information in the change code line information set represents the position information of the code difference between the target source file and a history source file, and the version corresponding to the history source file is earlier than the target version;

generating a target text according to the coverage rate information text, wherein the target text represents the coverage rate information of the change code line information set;

and generating a delta code coverage report aiming at the target source file according to the target text.

2. The method of claim 1, wherein the method further comprises:

and responding to the received report display request, and sending the incremental code coverage report to a report inquiry display terminal.

3. The method of claim 1, wherein the method further comprises:

and adjusting the test case corresponding to the target source file according to the increment code coverage rate report.

4. The method of claim 1, wherein changing code line information in the set of changing code line information comprises: file name and change code line of the transcoded file.

5. The method of claim 4, wherein the generating target text from the coverage information text comprises:

determining at least one change file name in the target source file for the historical source file;

generating a change text according to the at least one change file name and the coverage rate information text, wherein the text content of the change text is the content which is associated with the at least one change file name in the coverage rate information text content, and the coverage rate information text content is the text content of the coverage rate information text;

and generating the target text according to the change text and the change code lines and file names included in the change code line information set.

6. The method of claim 5, wherein the determining at least one alteration file name in the target source file for the historical source file comprises:

determining code branch information and a code submission record according to the code execution condition file;

and generating the at least one change text name according to the code branch information and the code submission record.

7. A report generating apparatus comprising:

a first generating unit configured to generate a coverage information text according to a code execution situation file for a target source file, wherein the target source file is a target version of a source file;

a determining unit configured to determine a change code line information set, wherein change code line information in the change code line information set characterizes position information of a code difference of the target source file and a history source file, wherein a version corresponding to the history source file is earlier than the target version;

a second generating unit configured to generate a target text according to the coverage information text, wherein the target text represents coverage information of the change code line information set;

a third generating unit configured to generate a delta code coverage report for the target source file according to the target text.

8. An electronic device, comprising:

one or more processors;

a storage device having one or more programs stored thereon,

when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-6.

9. A computer-readable medium, on which a computer program is stored, wherein the program, when executed by a processor, implements the method of any one of claims 1-6.

10. A computer program product comprising a computer program which, when executed by a processor, implements the method according to any one of claims 1-6.

Images