CN109783358B - Regression test driven software version management method, system and storage medium - Google Patents
Regression test driven software version management method, system and storage medium Download PDFInfo
- Publication number
- CN109783358B CN109783358B CN201811535329.2A CN201811535329A CN109783358B CN 109783358 B CN109783358 B CN 109783358B CN 201811535329 A CN201811535329 A CN 201811535329A CN 109783358 B CN109783358 B CN 109783358B
- Authority
- CN
- China
- Prior art keywords
- software
- test
- version
- source program
- program
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 135
- 238000007726 management method Methods 0.000 title claims abstract description 50
- 238000012795 verification Methods 0.000 claims abstract description 51
- 238000000034 method Methods 0.000 claims abstract description 35
- 230000002159 abnormal effect Effects 0.000 claims description 11
- 238000004458 analytical method Methods 0.000 claims description 6
- 238000004422 calculation algorithm Methods 0.000 claims description 4
- 238000004364 calculation method Methods 0.000 claims description 3
- 238000004590 computer program Methods 0.000 claims description 3
- 238000012827 research and development Methods 0.000 abstract description 13
- 238000011161 development Methods 0.000 description 8
- 230000007547 defect Effects 0.000 description 6
- 230000008569 process Effects 0.000 description 6
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000008859 change Effects 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 238000012384 transportation and delivery Methods 0.000 description 2
- 230000005856 abnormality Effects 0.000 description 1
- 238000012937 correction Methods 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 238000013439 planning Methods 0.000 description 1
- 238000011160 research Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
Images
Landscapes
- Debugging And Monitoring (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a regression test driven software version management method, a regression test driven software version management system and a storage medium, wherein the method comprises the following steps: performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version of software source program to obtain a first coverage result; according to the first covering result, automatically generating a test case for the newly submitted source program; performing second-stage verification on the newly submitted source program by adopting the generated test case to obtain a second coverage result; according to the second covering result, compiling a new test case, and generating a test program of a newly submitted source program; and calculating the check file and the version number of the test program, and generating new version software by combining the check file and the version number of the newly submitted source program. The invention can effectively solve the problems that the current SVM tool is difficult to effectively support the management of the test codes and the regression test information cannot be fully utilized, thereby helping research and development personnel to improve the software version management quality and improving the research and development efficiency of software products.
Description
Technical Field
The invention relates to a regression test driven software version management method, a regression test driven software version management system and a regression test driven software version management storage medium, and belongs to the technical field of software evolution analysis.
Background
The traditional software development process specifies a fixed mode of software development, for example, a waterfall model divides the software development process into six basic stages of planning, demand analysis, software design, program compiling, software testing, operation maintenance and the like, and research and development personnel sequentially complete the steps. However, with the rapid development of the software industry, the software is larger and larger in scale, the complex programs are higher and higher, and the problem of out-of-control software development period and development cost is serious. At this time, an agile development model emphasizing iterative development, incremental delivery, continuous integration and feedback promotion is produced, and is widely recognized in the industry by virtue of the capabilities of rapid development, rapid delivery and rapid response. In the agile development process, a large project may be decomposed into a plurality of sub-projects which are mutually connected and can run independently, and the development process requires that research and development personnel actively embrace changes when meeting the requirement change, so that a plurality of different software versions are generated. At this time, an application Software Version Management tool SVM (Software Version Management) is required to perform recording and Management to help research and development personnel to better understand the functions and performances of Software at different periods.
At present, software version management becomes an important part in the current software development process, and various software version management methods are successively proposed in academia and industry, and various mature SVM tools (such as CVS, SVN, Git and the like) are developed. Through the SVM tool, research and development personnel can store the modification history of directories and files, support the configuration management activity of software, track the development and maintenance activities of a plurality of versions and release related information of the software, and the functions play a vital role in improving the research and development efficiency of software products. However, while current SVM tools have provided good support for management of software source programs, effective support for management of test code contained by software has not been provided. Most of traditional SVM tools regard test codes as a part of software source programs, and research personnel need to maintain the test codes of each software version by themselves; in addition, when a new version is submitted, due to reasons of function change, error correction, format adjustment and the like, the test case of the previous version may be unavailable, insufficient and the like, and the test case needs to be corrected and supplemented manually, which is time-consuming and labor-consuming.
Disclosure of Invention
The invention aims to overcome the defects in the prior art, provides a regression test driven software version management method, a regression test driven software version management system and a regression test driven software version management storage medium, and can effectively solve the problems that the current SVM tool is difficult to effectively support the management of test codes, and regression test information cannot be fully utilized, so that research and development personnel are helped to improve the software version management quality and improve the research and development efficiency of software products.
In order to achieve the purpose, the invention is realized by adopting the following technical scheme:
in a first aspect, the present invention provides a regression test-driven software version management method, including the following steps:
performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version of software source program to obtain a first coverage result;
according to the first covering result, automatically generating a test case for the newly submitted source program;
performing second-stage verification on the newly submitted source program by adopting the generated test case to obtain a second coverage result;
according to the second covering result, compiling a new test case, and generating a test program of a newly submitted source program;
and calculating the check file and the version number of the test program, and generating new version software by combining the check file and the version number of the newly submitted source program.
With reference to the first aspect, further, the method for obtaining the available test case includes:
searching a test case of a previous software version according to a given software warehouse and a source program of a current software version;
and carrying out availability analysis on the test case of the previous software version, and taking the available test case obtained by analysis as the available test case of the source program of the new version software.
With reference to the first aspect, further, the method for second-stage verification includes:
the method comprises the steps that a given source program of a current software version, a first coverage result and a maximum window width are used for limiting the maximum number of automatically generated results of testing, and statements except the first coverage result are used as testing targets to generate an abnormal error test case based on a random strategy;
and detecting the abnormal errors contained in the newly submitted source program by adopting the abnormal error test case.
With reference to the first aspect, further, if the new submitted source program fails to pass the first-stage verification or the second-stage verification, the new version software source program is modified in a return mode.
With reference to the first aspect, further, the method for generating the new version software includes:
respectively calculating the total Checksum of the binary version of the test program and the total Checksum of the binary version of the source program of the new version software by adopting a Checksum algorithm, and generating a check file of the test program and a check file of the source program of the new version software;
generating a new version software check file according to the check file of the test program and the check file of the new version software source program;
adopting GNU or Windows or Net Framework style to make version number of the test program and version number of the new version software source program;
combining the version number of the test program and the version number of the new-version software source program to generate a new-version software version number;
and generating the new version software according to the new version software check file and the new version software version number.
With reference to the first aspect, further, the check file includes a parity check code, an xor check code, a CRC check code, an LRC check code, a gray code check code, and an MD5 check code.
In a second aspect, an embodiment of the present invention provides a regression test-driven software version management system, where the system includes:
a first verification module: the method comprises the steps of performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version software source program to obtain a first coverage result;
a test case generation module: the automatic generation module is used for automatically generating the test case for the newly submitted source program according to the first coverage result;
a second verification module: the second-stage verification is carried out on the newly submitted source program by adopting the generated test case, and a second coverage result is obtained;
a compiling module: the test case is compiled according to the second coverage result, and a test program of a new submission source program is generated;
a calculation module: the verification file and the version number are used for calculating the test program;
a new version software generation module: and the software version generation module is used for generating new version software according to the check file and the version number of the test program and the check file and the version number of the newly submitted source program.
In a third aspect, an embodiment of the present invention further provides a regression test driven software version management system, including a processor and a storage medium;
the storage medium is used for storing instructions;
the processor is configured to operate in accordance with the instructions to perform the steps according to the aforementioned method.
In a fourth aspect, an embodiment of the present invention provides a computer-readable storage medium, on which a computer program is stored, wherein the program is configured to implement the steps of the foregoing method when executed by a processor.
In summary, the regression test driven software version management method, the regression test driven software version management system and the storage medium provided by the embodiment of the invention can effectively solve the problems that the current SVM tool is difficult to effectively support the management of the test codes and the regression test information cannot be fully utilized, thereby helping research and development personnel to improve the software version management quality and improve the research and development efficiency of software products.
Drawings
FIG. 1 is a flowchart of a regression test-driven software version management method according to an embodiment of the present invention;
FIG. 2 is a flow chart of a method for automatic verification of the software version of FIG. 1;
FIG. 3 is a flow chart of a method for automatic test case generation of FIG. 1;
FIG. 4 is a flowchart of a method for automatic management of test versions of FIG. 1;
fig. 5 is a flowchart of the software version automatic management method in fig. 1.
Detailed Description
The invention is further described below with reference to the accompanying drawings. The following examples are only for illustrating the technical solutions of the present invention more clearly, and the protection scope of the present invention is not limited thereby.
Fig. 1 is a flowchart of a regression test-driven software version management method according to an embodiment of the present invention, including the following steps:
step1 software version automatic verification: aiming at a source program version newly submitted by a user, analyzing an available test case in a test program corresponding to a source program of a previous version of the version, and detecting defects in the newly submitted source program by using the available test case: if the defect exists, the source program is indicated to have a problem and needs to be modified and then submitted again; otherwise, the source program passes the first stage verification, and at this time, the available test case and the coverage information thereof are output to guide the automatic generation of the test of the next stage.
Step2 test case automatic generation: the above step uncovered statements are used as test targets to carry out automatic generation of tests for the new submission source program, and the newly generated test cases are continuously executed while the new submission source program is generated so as to observe whether the new submission source program generates abnormal errors: if the exception occurs, the source program is indicated to have a problem and needs to be modified and then submitted again; otherwise, the source program passes the second stage verification, and the newly generated test case and the coverage information are output at the moment to guide the next stage test case writing. In the test automatic generation process, a stop criterion is constructed according to the satisfaction condition of the uncovered result in the previous stage.
Step3 test version automatic management: the previous two steps of uncovered statements are used as test targets to write test cases for a new submission source program, and the newly generated test cases are continuously executed while writing so as to detect defects in the new submission source program: if the defect exists, the source program is indicated to have a problem and needs to be modified and then submitted again; otherwise, the source program passes the third stage verification, and at this time, a new test program is generated based on the test cases generated in the first two steps, the check code of the test program is calculated, and the check file of the test program is output.
Step4 software version automatic management: calculating and generating a version number of a newly submitted source program, and generating a version number of software by cooperating with the version number of the test program; analyzing and generating a verification file of a newly submitted source program, and generating a verification file of software in cooperation with the verification file of the test program; and after the software version number and the check file are generated, the generated software version number and the check file are stored in a software warehouse together with the newly submitted source program and the corresponding test program, so that the generation and the registration of the new software version are completed.
Fig. 2 is a flow chart of automatic verification of software versions. Aiming at the newly submitted source program version, the available test cases of the newly submitted source program are identified by analyzing the test program corresponding to the previous version, the newly submitted source program is automatically verified by executing the test cases, and meanwhile, the coverage information is generated to provide guidance for automatic test generation. The method comprises the following specific steps:
step 1: an initial state;
step 2: inputting a software warehouse SR and a current version Pi of a source program;
and step 3: judging whether Pi is an initial version P0, if so, executing a step4, otherwise, executing a step 6;
and 4, step 4: initializing a test case set Toldi to be NULL;
and 5: initializing the coverage information cov (Toldi) of Toldi to be NULL, and executing step 10;
step 6: extracting software version Vi-1 of a previous version of Pi from the SR, wherein the software version Vi-1 is < IDVi-1, Pi-1, Ti-1, CC _ FILE _ Vi-1>, IDVi-1, Pi-1, Ti-1 and CC _ FILE _ Vi-1 respectively represent the version number of Vi-1, a source program, a test program and a check FILE;
and 7: identifying all available test cases for Pi in Ti-1 constitutes Toldi;
and 8: executing Toldi by applying Pi, further dividing Toldi into a successful test case set Told _ passei and a failed test case set Told _ failedi according to an execution result, and recording the coverage information of Toldi;
and step 9: judging whether the content in the Told _ failedi is empty NULL, if so, executing the step 10, otherwise, executing the step 11;
step 10: pi passes stage 1 verification, outputs Toldi and cov (Toldi), and executes step 12;
step 11: pi does not pass the verification of the stage 1, and outputs Told _ failedi;
step 12: and ending the state.
FIG. 3 is a flow chart of automatic test case generation. And taking a code area which cannot be covered by the previous version test program as a test target to develop test automatic generation, developing abnormal error detection of a new version source program by using the new generation program, and recording the covering information of the automatically generated test case. The stop criteria are built with code coverage at test generation. The method comprises the following specific steps:
step 1: an initial state;
step 2: inputting the coverage information cov (Toldi) and the window width window of the current version Pi and Pi of the source program on Toldi;
and step 3: calculating an uncovered code region uncovered in Pi, noncov (Toldi);
and 4, step 4: initializing the test case set Tnew _ auto to be NULL, and initializing the values of all elements in a coverage sequence listcov ═ cov1, cov2, … and covwindow ≧ NULL;
and 5: randomly generating a test case t aiming at the Pi;
step 6: executing t and calculating coverage information cov (t);
and 7: judging whether abnormality occurs during execution of t, if so, executing step 14, otherwise, executing step 8;
and 8: add t to Tnew _ autoi, i.e.: tnew _ autoi ═ Tnew _ autoi { t };
and step 9: updating the covering sequence listcov;
step 10: judging cov (Tnew _ autoi) whether all statements in noncov (toddi) are included, if yes, executing step 13, otherwise, executing step 11;
step 11: judging whether the number of the test cases in the Tnew _ autoi is larger than the window, if so, executing a step 12, otherwise, executing a step 5;
step 12: judging whether the values of all elements in the listcov are the same or not, if so, executing a step 13, and otherwise, executing a step 5;
step 13: pi passes phase 2 verification, outputs Tnew _ autoi and cov (Tnew _ autoi), executes step 15;
step 14: pi does not pass the verification of the 2 nd stage, and a test case t causing Pi abnormity is output; step 15: and ending the state.
Fig. 4 is a flowchart of automatic management of test versions. And writing the test cases by taking the code areas which cannot be covered by the former version test program and the automatically generated test cases as test targets, and detecting defects in the newly submitted source program by using the test targets. And after the source program passes the verification, combining and generating the test program corresponding to the newly submitted source program, the version number and the verification file thereof. The method comprises the following specific steps:
step 1: an initial state;
step 2: inputting a current version Pi of a source program, a test case Toldi and coverage information cov (Toldi) available for a previous version, and automatically generated test case Tnew _ autoi and coverage information cov (Tnew _ autoi);
and step 3: calculating an uncovered code region uncav (Toldi & _ Tnew _ autoi) in Pi;
and 4, step 4: writing a new test case Tnew _ manuali for Pi by using uncov (Toldi @ Tnew _ autoi) as a test target;
and 5: executing the Tnew _ manual by using Pi, and further dividing the Tnew _ manual into a successful test case set Tnew _ manual _ pasedi and a failed test case set Tnew _ manual _ failed according to an execution result;
step 6: judging whether the Tnew _ manual _ failed is empty NULL or not, if so, executing a step 7, otherwise, executing a step 12;
and 7: combining Toldi, Tnew _ autoi and Tnew _ manuali to generate a test program Ti corresponding to Pi;
and 8: adopting GNU, Windows, Net Framework and other formats to formulate the version number IDTi of the test program Ti;
and step 9: generating check codes of files such as Toldi, Tnew _ auto, Tnew _ manual and the like by adopting parity check, exclusive OR check, CRC check, LRC check, Gray code check, MD5 check and the like;
step 10: calculating the total Checksum of the Ti binary version by adopting a Checksum algorithm, and generating a checking FILE CC _ FILE _ Ti of Ti, wherein the content of the checking FILE CC _ FILE _ Ti comprises checking codes of FILEs such as Toldi, Tnew _ autoi, Tnew _ manuali, Ti and the like;
step 11: pi passes the 3 rd stage verification, outputs Ti, IDTi and CC _ FILE _ Ti, and executes the step 13;
step 12: pi does not pass the verification of the 3 rd stage, and Tnew _ manual _ failedi is output; step 13: and ending the state.
Fig. 5 is a flowchart of automatic management of software versions. Analyzing and generating a version number of a newly submitted source program, and generating a version number of new version software in cooperation with the version number of the test program; analyzing and generating a verification file of a newly submitted source program, and generating a verification file of new version software in cooperation with the verification file of the test program; and adding the new version into the software warehouse, and finishing the registration and release of the new version of the software. The method comprises the following specific steps:
step 1: an initial state;
step 2: inputting a current version Pi of a source program, a corresponding test program Ti, a test program version number IDTi and a check FILE CC _ FILE _ Ti;
and step 3: adopting GNU, Windows, Net Framework and other formats to make the version number IDPi of the source program;
and 4, step 4: combining the source program version number and the test program version number to generate a software version number IDVi which is < IDPi, IDTi >;
and 5: calculating the total Checksum of the binary version of Pi by adopting a Checksum algorithm, and generating a checking FILE CC _ FILE _ Pi of Pi, wherein the content of the checking FILE CC _ FILE _ Pi comprises checking codes of FILEs such as CC _ FILE _ Pi and the like;
step 6: combining the contents in the CC _ FILE _ Pi and the CC _ FILE _ Ti to generate a check FILE CC _ FILE _ Vi of a software version Vi, wherein the contents comprise check codes of FILEs such as Pi, Toldi, Tnew _ auto, Tnew _ manual, Ti and the like;
and 7: adding software version Vi ═ IDPi, Pi, Ti and CC _ FILE _ Vi > into the software repository SR;
and 8: outputting a current software warehouse SR and a software version Vi;
and step 9: and ending the state.
In conclusion, the method and the device solve the problems that the current SVM tool is difficult to effectively support the management of the test codes and the regression test information is not fully utilized, so that the functions of SVM tool software products can be enhanced, research and development personnel are helped to improve the software version management quality, and the aims of improving the software product research and development efficiency and guaranteeing the software product quality are finally fulfilled.
The embodiment of the present invention further provides a regression test-driven software version management system, where the system can be used to execute the regression test-driven software version management method, and the method includes:
a first verification module: the method comprises the steps of performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version software source program to obtain a first coverage result;
a test case generation module: the automatic generation module is used for automatically generating the test case for the newly submitted source program according to the first coverage result;
a second verification module: the second-stage verification is carried out on the newly submitted source program by adopting the generated test case, and a second coverage result is obtained;
a compiling module: the test case is compiled according to the second coverage result, and a test program of a new submission source program is generated;
a calculation module: the verification file and the version number are used for calculating the test program;
a new version software generation module: and the software version generation module is used for generating new version software according to the check file and the version number of the test program and the check file and the version number of the newly submitted source program.
The embodiment of the invention also provides a regression test driven software version management system, which can also be used for executing the regression test driven software version management method, and comprises a processor and a storage medium;
the storage medium is used for storing instructions;
the processor is configured to operate in accordance with the instructions to perform steps in accordance with the aforementioned method.
Embodiments of the present invention also provide a computer-readable storage medium, on which a computer program is stored, which when executed by a processor implements the steps of the aforementioned method.
The above description is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, several modifications and variations can be made without departing from the technical principle of the present invention, and these modifications and variations should also be regarded as the protection scope of the present invention.
Claims (8)
1. A regression test driven software version management method is characterized by comprising the following steps:
performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version of software source program to obtain a first coverage result;
according to the first covering result, automatically generating a test case for the newly submitted source program;
performing second-stage verification on the newly submitted source program by adopting the generated test case to obtain a second coverage result;
according to the second covering result, compiling a new test case, and generating a test program of a newly submitted source program;
calculating a check file and a version number of the test program, and generating new version software by combining the check file and the version number of the newly submitted source program;
the second stage verification method comprises the following steps:
the method comprises the steps that given source programs of current software versions, first coverage results and a maximum window width, the width is used for limiting the maximum number of automatically generated results of testing, and statements except the first coverage results are used as testing targets to generate abnormal error test cases based on random strategies;
and detecting the abnormal errors contained in the newly submitted source program by adopting the abnormal error test case.
2. The regression test-driven software version management method according to claim 1, wherein the method for acquiring the available test cases comprises:
searching a test case of a previous software version according to a given software warehouse and a source program of a current software version;
and carrying out availability analysis on the test case of the previous software version, and taking the available test case obtained by analysis as the available test case of the source program of the new version software.
3. The regression test-driven software version management method according to claim 1, wherein if the new submission source program fails the first-stage verification or the second-stage verification, the new version software source program is returned to be modified.
4. The regression test driven software version management method according to claim 1, wherein the method of generating the new version software comprises:
respectively calculating the total Checksum of the binary version of the test program and the total Checksum of the binary version of the source program of the new version software by adopting a Checksum algorithm, and generating a check file of the test program and a check file of the source program of the new version software;
generating a new version software check file according to the check file of the test program and the check file of the new version software source program;
adopting GNU or Windows or Net Framework style to make version number of test program and version number of new version software source program;
combining the version number of the test program and the version number of the new-version software source program to generate a new-version software version number;
and generating the new version software according to the new version software check file and the new version software version number.
5. The regression test driven software version management method according to claim 4, wherein the check file includes parity check codes, XOR check codes, CRC check codes, LRC check codes, Gray code check codes, and MD5 check codes.
6. A regression test driven software version management system, the system comprising:
a first verification module: the method comprises the steps of performing first-stage verification on a newly submitted source program by adopting an available test case in a test program corresponding to a previous version software source program to obtain a first coverage result;
a test case generation module: the automatic generation module is used for automatically generating the test case for the newly submitted source program according to the first coverage result;
a second verification module: the second-stage verification is carried out on the newly submitted source program by adopting the generated test case, and a second coverage result is obtained;
a compiling module: the test case is compiled according to the second coverage result, and a test program of a new submission source program is generated;
a calculation module: the verification file and the version number are used for calculating the test program;
a new version software generation module: the software version verification system is used for generating new version software according to the verification file and the version number of the test program and the verification file and the version number of the newly submitted source program;
the second stage verification method comprises the following steps:
the method comprises the steps that a given source program of a current software version, a first coverage result and a maximum window width are used for limiting the maximum number of automatically generated results of testing, and statements except the first coverage result are used as testing targets to generate an abnormal error test case based on a random strategy;
and detecting the abnormal errors contained in the newly submitted source program by adopting the abnormal error test case.
7. A regression test driven software version management system is characterized by comprising a processor and a storage medium;
the storage medium is used for storing instructions;
the processor is configured to operate in accordance with the instructions to perform the steps of the method according to any one of claims 1 to 5.
8. Computer-readable storage medium, on which a computer program is stored, which program, when being executed by a processor, is adapted to carry out the steps of the method of any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811535329.2A CN109783358B (en) | 2018-12-14 | 2018-12-14 | Regression test driven software version management method, system and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811535329.2A CN109783358B (en) | 2018-12-14 | 2018-12-14 | Regression test driven software version management method, system and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109783358A CN109783358A (en) | 2019-05-21 |
| CN109783358B true CN109783358B (en) | 2022-05-27 |
Family
ID=66496967
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811535329.2A Active CN109783358B (en) | 2018-12-14 | 2018-12-14 | Regression test driven software version management method, system and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109783358B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112613894B (en) * | 2020-12-31 | 2024-04-16 | 中国农业银行股份有限公司 | Method and device for associating source code with product |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102831060A (en) * | 2012-08-24 | 2012-12-19 | 东南大学 | Modification influence analysis based regression test case updating method of part software |
| CN103123607A (en) * | 2013-03-08 | 2013-05-29 | 扬州大学 | Software regression testing method based on formal conceptual analysis |
| CN103699385A (en) * | 2013-12-23 | 2014-04-02 | 国云科技股份有限公司 | Continuous code integration method |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9411710B2 (en) * | 2014-08-01 | 2016-08-09 | Unisys Corporation | Automated regression test case selector and black box test coverage tool for product testing |
-
2018
- 2018-12-14 CN CN201811535329.2A patent/CN109783358B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102831060A (en) * | 2012-08-24 | 2012-12-19 | 东南大学 | Modification influence analysis based regression test case updating method of part software |
| CN103123607A (en) * | 2013-03-08 | 2013-05-29 | 扬州大学 | Software regression testing method based on formal conceptual analysis |
| CN103699385A (en) * | 2013-12-23 | 2014-04-02 | 国云科技股份有限公司 | Continuous code integration method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109783358A (en) | 2019-05-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP2960799A1 (en) | Defect localization in software integration tests | |
| EP3265916B1 (en) | A method for identifying a cause for a failure of a test | |
| US9760073B2 (en) | Technique and tool for efficient testing of controllers in development | |
| KR20150046088A (en) | Predicting software build errors | |
| CN103279418B (en) | A kind of method of testing of configuration control information and device | |
| US20150269060A1 (en) | Development tools for logging and analyzing software bugs | |
| US20120030652A1 (en) | Mechanism for Describing Values of Optimized Away Parameters in a Compiler-Generated Debug Output | |
| US20140282445A1 (en) | Automated code analyzer | |
| US10579513B2 (en) | Test run control method and apparatus | |
| US7181729B2 (en) | Methods and systems for an interactive theorem-proving tool with reflective capabilities | |
| CN112988594A (en) | Integrated detection method and system for code quality evaluation | |
| CN109783358B (en) | Regression test driven software version management method, system and storage medium | |
| CN112685320B (en) | Software defect repairing method and device based on multiple candidate programs | |
| EP3805933A1 (en) | Method and device for measuring the complexity of a computer program | |
| KR20120111618A (en) | Apparatus and method for testing plc command | |
| CN115408049A (en) | File version control method and device and electronic equipment | |
| CN106909500B (en) | Method and system for detecting errors introduced in airborne software development process | |
| JP7190246B2 (en) | Software failure prediction device | |
| CN112732588A (en) | Artificial intelligence code verification system, method and device based on cloud computing | |
| US11416363B2 (en) | Method for risk-based testing | |
| Weissberger et al. | Delivering software engineering education through LEGO robotics | |
| Umudova | Analysis of software maintenance phases | |
| US10970636B1 (en) | Adaptive system for predicting integration failures in large systems | |
| Mendonça et al. | Feature-oriented Test Case Selection during Evolution of Highly-Configurable Systems | |
| JP2014071775A (en) | System development support device and system development support method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |