CN116560984A - Test case clustering grouping method based on call dependency graph - Google Patents
Test case clustering grouping method based on call dependency graph Download PDFInfo
- Publication number
- CN116560984A CN116560984A CN202310459023.8A CN202310459023A CN116560984A CN 116560984 A CN116560984 A CN 116560984A CN 202310459023 A CN202310459023 A CN 202310459023A CN 116560984 A CN116560984 A CN 116560984A
- Authority
- CN
- China
- Prior art keywords
- graph
- node
- test case
- call dependency
- test
- 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.)
- Pending
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 127
- 238000000034 method Methods 0.000 title claims abstract description 58
- 239000011159 matrix material Substances 0.000 claims abstract description 45
- 238000004422 calculation algorithm Methods 0.000 claims abstract description 18
- 230000006399 behavior Effects 0.000 claims abstract description 9
- 230000003595 spectral effect Effects 0.000 claims description 16
- 239000013598 vector Substances 0.000 claims description 15
- 238000004458 analytical method Methods 0.000 claims description 9
- 230000003068 static effect Effects 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 6
- 238000013507 mapping Methods 0.000 claims description 6
- 238000010276 construction Methods 0.000 claims description 3
- 238000012804 iterative process Methods 0.000 claims description 2
- 238000004806 packaging method and process Methods 0.000 claims 1
- 238000012423 maintenance Methods 0.000 abstract description 3
- 230000002708 enhancing effect Effects 0.000 abstract description 2
- 238000007621 cluster analysis Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000006698 induction Effects 0.000 description 1
- 230000001939 inductive effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 238000010998 test method Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F18/00—Pattern recognition
- G06F18/20—Analysing
- G06F18/23—Clustering techniques
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Life Sciences & Earth Sciences (AREA)
- Quality & Reliability (AREA)
- Computer Hardware Design (AREA)
- Artificial Intelligence (AREA)
- Bioinformatics & Cheminformatics (AREA)
- Bioinformatics & Computational Biology (AREA)
- Computer Vision & Pattern Recognition (AREA)
- Evolutionary Biology (AREA)
- Evolutionary Computation (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a test case clustering grouping method based on a call dependency graph, which comprises the steps of firstly constructing the call dependency graph of a test case, converting the call dependency graph into a graph with attributes of nodes, then calculating the similarity between the graphs with the attributes of the test case by using a shortest path graph kernel, then solving a similarity matrix representing the similarity of the whole test kit, and finally clustering and grouping the test case. According to the method, all test cases in the test suite are extracted by using the Java Parser, and call dependency relations between assertions and other code sentences are analyzed. Compared with other readability enhancing tools, the method solves the problems that the sequence of a large number of test cases automatically constructed by the random unit test case generating tool is random and disordered, some test cases check similar functional behaviors and the like, and groups the test cases by using a similarity relation and a clustering algorithm, so that the readability and the comprehensiveness of the test cases are improved, the maintenance cost is reduced, and the efficiency of software development and testing is improved.
Description
Technical Field
The invention relates to a method for constructing a call dependency graph and clustering grouping aiming at a large number of test cases automatically created by a random unit test case generating tool, and belongs to the technical field of software testing.
Background
The automatic unit test case generating tool can generate unit tests with higher quality, effectively reduces the cost of manually writing the tests, and improves the efficiency of software development. The unit test case generating tool using the random method has the characteristics of easiness in implementation, strong expandability, high code coverage rate and the like, randomly selects test input from an input space of a program, and generates a method sequence in an increment mode. However, the number of test cases automatically built by the random unit test case generation tool is excessive and the readability is poor. The existing readability enhancing tool mostly enhances readability by adding notes to automatically generated test cases or creating more descriptive test method names and the like, but ignores the problems that a large number of test cases constructed by the random unit test case generating tool usually have repeated similar functional behaviors, and meanwhile ignores the problems of lack induction, disorder, strong randomness, poor readability and the like caused by the repeated similar functional behaviors.
Disclosure of Invention
The invention aims to: the random unit test case generating tool can automatically construct test cases with strong expandability and high code coverage rate, but the number of the generated test cases is larger, and the test cases are random and disordered at the same time, and some of the test cases have repeated similar functional behaviors. Aiming at the problems and the defects existing in the prior art, the invention provides a test case clustering grouping method based on a call dependency graph, which is used for inducing and grouping test cases according to structures and contents in a clustering mode, so that the readability of the test cases is improved, the maintenance cost is reduced, and the efficiency of a software development process is improved.
The technical scheme is as follows: a test case clustering grouping method based on a call dependency graph comprises the following steps:
step 1, firstly, carrying out static analysis on unit test case codes created by an automation tool, and constructing a call dependency graph of the test case from each assertion;
step 2, converting the call dependency Graph of the test case into an attribute Graph (Attribute Graph);
step 3, calculating the similarity between the attribute-carrying graphs of the test cases by using a graph kernel-based method, and acquiring a similarity matrix of the whole test suite;
step 4, taking the similarity matrix as input, clustering the test cases based on the input matrix by using a spectral clustering algorithm, and obtaining a clustering result;
and step 5, grouping the test cases based on the clustering result, and outputting the grouped test case files.
In the step 1, after the test case created by the automated test generation tool is obtained, a corresponding call dependency graph is constructed by using a static analysis method, and the specific implementation process is as follows:
11 Extracting all marked @ Test annotated Test cases in the Test suite by using the Java Parser;
12 Analyzing the call dependency relationship between each assertion and other code statements in the test case; the identifier is identified and call dependencies are found by defining rules.
The code expression declares the object, but the expression does not contain any other variables, and only the name of the declared object is detected to be an identifier searched by the forward node; if yes, adding the current node to the graph without updating the identifier set, and continuously searching for the subsequent node; if not, continuing to search for the target node.
The code expression declares the object and assigns or instantiates the object by calling the constructor, using the static fields of the class instance, calling the method, etc., and other variables are used in the expression, then it is checked whether the declared object name is the identifier that the forward node looks for. If yes, adding the current node into the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, but the identifier found by the forward node is detected to be other variables (such as parameters) in the expression, the current node is still added to the graph, the current identifier set is updated, and then the subsequent neighbor nodes are found.
The code expression only has method call, does not declare any object, and only needs to detect whether the identifier searched by the forward node is used in the expression; if the current node is included, adding the current node to the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, continuing to search for the target node.
13 Beginning with each assertion, a call dependency graph of the test case is constructed inversely from the call dependencies. The definition of the nodes and edges of the call dependency graph is: the nodes contain content information such as numbers, code sentences, subsequent neighbor nodes and the like; an edge indicates that there is a direct calling behavior between the code statements of the two nodes it connects, but does not store the actual content. Constructing a call dependency graph starts from the assertion of the test case and continuously searches for call dependency relationships among code sentences until the dependency ends. Firstly, all assertion sentences in test case codes are acquired and packaged into nodes, and the nodes are used as subsequent neighbor nodes of a head node. Then, starting from each assertion node, constructing and iterating a call dependency relationship based on a work queue, wherein the work queue refers to a queue containing all current nodes to be processed, and the initial state of the work queue only contains the current assertion node. The analysis process of the call dependency relationship is as follows: each identifier contained in the code statement of a node in the work queue is identified and iterated, and for each use and definition of the identifier, the corresponding node and edge are added to the graph and the work queue and the list of successor neighbor nodes to the current node are updated. When the work queue is empty, the call dependency of the predicate node ends. And finally, for each assertion node, executing the analysis process of the calling dependency relationship until the calling dependency relationship of all assertion nodes is finished, and completing the construction of the calling dependency graph.
In the step 2, the topology structure and node information of the call dependency graph of the test case are analyzed, and the call dependency graph is converted into a node band attribute graph, and the band attribute graph can be processed by a graph kernel tool GraKel. GraKeL is a library containing multiple graph kernels and generic frameworks, which can be used for graph clustering tasks. The specific implementation process is as follows:
21 Constructing nodes with attribute graphs, and mapping relationships between nodes in the call dependency graph to edges of the call dependency graph, wherein the relationships between nodes with attribute graphs need to be consistent with the call dependency graph.
22 Extracting the object type and the name of the tested method stated in the code statement of the node in the calling dependency graph, and solving the corresponding one-hot coding feature vector to be used as the attribute value of the node with the attribute graph.
In the step 3, the specific implementation process is as follows:
31 Using the shortest path graph kernel provided by GraKel to calculate the similarity between the tape property graphs of two test cases. The shortest path kernel is a typical graph kernel method that breaks the graph into shortest paths and compares pairs of shortest paths based on the shortest path lengths between nodes and dot products between node attribute values.
32 Calculating the similarity among all the test cases in the manner introduced in the step 31), and finally solving a similarity matrix representing the similarity relation of the whole test suite.
In the step 4, a spectral clustering algorithm is used to calculate the clustering result of the test case, and the specific implementation process is as follows:
41 The similarity matrix obtained in the step 3 is used as input of a spectral clustering algorithm, and the similarity matrix can be regarded as an adjacent matrix of the graph model and is commonly used for constructing the graph model. Specifically, the elements in the similarity matrix represent the degree of similarity between samples, which can be regarded as edge weights in an undirected weighted graph. And then the spectral clustering algorithm calculates a Laplacian matrix and a spectral matrix based on the similarity matrix, and then obtains the characteristic value and the characteristic vector.
42 Firstly, arranging the characteristic values from small to large, and then selecting the characteristic vectors corresponding to the minimum k characteristic values as a characteristic vector matrix after dimension reduction, wherein each row of the matrix is the characteristic of sample mapping. The invention adopts a method for maximizing the characteristic cracks to obtain the optimal k value.
43 And finally, clustering the feature vector matrix after the dimension reduction by using a KMeans clustering algorithm, and finally obtaining a clustering result of the test case. KMeans is an iteratively solved cluster analysis algorithm that randomly selects k initial cluster centers (where the k value is the same as the k value found in 42), and then assigns each data point to the nearest cluster while keeping the distance of the intra-cluster object to the cluster center as small as possible.
A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing a call dependency graph based test case clustering method as described above when executing the computer program.
A computer-readable storage medium storing a computer program that performs the call dependency graph-based test case clustering method described above.
Compared with the prior art, the invention has the following advantages:
1) And constructing a call dependency graph of the test cases based on the relation between the assertion and other code sentences, and calculating the similarity between the graphs by using a shortest path graph kernel method, namely obtaining the similarity between the two test cases. Compared with the traditional Jaccard similarity index and cosine similarity combined word frequency inverse document frequency (TF-IDF) method, the similarity calculation method simultaneously considers the topological structure and node content information of the call dependency graph, can effectively balance statement call, dependency and assertion detection behaviors of test cases, and can be beneficial to obtaining better clustering effects.
2) According to the invention, the similarity matrix representing the similarity relation of the whole test suite can be obtained by constructing the call dependency graph and calculating the similarity by using the graph kernel, and the test cases are grouped by using a spectral clustering algorithm capable of processing the similarity matrix as input. The clustering can enable automatically generated test cases to be grouped according to the functional behaviors, so that the test cases are clearer and more orderly, and the readability and the understandability of the test cases are improved.
Drawings
FIG. 1 is an overview of a call dependency graph-based test case clustering method in accordance with an embodiment of the present invention.
Detailed Description
The present invention is further illustrated below in conjunction with specific embodiments, it being understood that these embodiments are meant to be illustrative of the invention only and not limiting the scope of the invention, and that modifications of the invention, which are equivalent to those skilled in the art to which the invention pertains, will fall within the scope of the invention as defined in the claims appended hereto.
The embodiment provides a test case clustering grouping method based on a call dependency graph, which improves the readability of unit test cases and reduces the maintenance cost.
The first step is to perform static analysis on the unit test case codes created by the automated unit test generation tool, and construct a call dependency graph of the test case from each assertion. The method comprises the following specific steps:
1) Extracting all marked @ Test annotated Test cases in the Test suite by using a JavaParser;
2) Next, analyzing the call dependency relationship between each assertion and other code sentences, identifying identifiers by defining rules, searching nodes according to the call dependency relationship and constructing a call dependency graph, wherein the specific rules are as follows: the code expression declares the object, but the expression does not contain any other variables, and only the name of the declared object is detected to be an identifier searched by the forward node; if yes, adding the current node to the graph without updating the identifier set, and continuously searching for the subsequent node; if not, continuing to search for the target node. The code expression declares the object, assigns or instantiates the object by means of a new key call constructor, a static field of a class instance, a call method and the like, and if other variables are used in the expression, firstly checking whether the declared object name is an identifier searched by a forward node; if yes, adding the current node into the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, but the identifier found by the forward node is detected to be other variables (such as parameters) in the expression, the current node is still added to the graph, the current identifier set is updated, and then the subsequent neighbor nodes are found. The code expression only has method call and does not declare any object, and then only needs to detect whether the identifier searched by the forward node is used in the expression; if the current node is included, adding the current node to the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, continuing to search for the target node.
3) From each assertion, a call dependency graph of the test case is constructed inversely according to the call dependency. The definition of the nodes and edges of the call dependency graph is: the nodes contain content information such as numbers, code sentences, subsequent neighbor nodes and the like; an edge indicates that there is a direct calling behavior between the code statements of the two nodes it connects, but does not store the actual content. Firstly, all assertion sentences in test case codes are acquired and packaged into nodes, and the nodes are used as subsequent neighbor nodes of a head node. Next, starting from each predicate node, an iterative process based on a work Queue (Queue) is performed, the work Queue initial state containing only the current predicate node. Each identifier contained in the code statement of a node in the work queue is identified and iterated, and for each use and definition of the identifier, the corresponding node and edge are added to the graph and the work queue and the list of successor neighbor nodes to the current node are updated. When the work queue is empty, the call dependency of the predicate node ends. And for each assertion node, executing the analysis process of the calling dependency relationship until the calling dependency relationship of all assertion nodes is finished, and completing the construction of the calling dependency graph.
And secondly, converting the call dependency Graph of the test case into an attribute Graph (Attribute Graph). Analyzing the topological structure and node information of the call dependency graph of the test case, converting the topological structure and the node information into a node attribute graph, constructing nodes with the attribute graph, and mapping the relation between the nodes in the call dependency graph to the edges of the attribute graph, wherein the relation between the nodes with the attribute graph is required to be consistent with the call dependency graph. And extracting the object types and the names of the tested methods declared in the code sentences of the nodes in the calling dependency graph, and solving the corresponding one-hot coding feature vectors to be used as the attribute values of the nodes with the attribute graph. The tape attribute map may be processed by the map kernel tool GraKel.
And thirdly, calculating the similarity between the test case attribute graphs by using a graph kernel-based method, and acquiring a similarity matrix of the whole test suite. The shortest path graph kernel provided by the graph kernel tool GraKel is used for calculating the similarity between the attribute graphs of two test cases, and GraKel is a library containing various graph kernels and a universal framework and can be used for graph clustering tasks. The shortest path kernel is a typical graph kernel method that breaks the graph into shortest paths and compares pairs of shortest paths based on the shortest path lengths between nodes and dot products between node attribute values. And then, calculating the similarity among all the test cases, and finally solving a similarity matrix representing the similarity relation of the whole test suite.
And fourthly, taking the similarity matrix as input, clustering the test cases based on the input matrix by using a spectral clustering algorithm, and obtaining a clustering result. The obtained similarity matrix is taken as input of a spectral clustering algorithm, and the similarity matrix can be regarded as an adjacent matrix of the graph model and is commonly used for constructing the graph model. Specifically, the elements in the similarity matrix represent the degree of similarity between samples, which can be regarded as edge weights in an undirected weighted graph. And then the spectral clustering algorithm calculates a Laplacian matrix and a spectral matrix based on the similarity matrix, and then obtains the characteristic value and the characteristic vector. The feature values are arranged from small to large, and then feature vectors corresponding to the k minimum feature values are selected as feature vector matrixes after dimension reduction, wherein each row of the matrixes is the feature of the sample mapping. The invention adopts a method for maximizing the characteristic cracks to obtain the optimal k value. And finally, clustering the feature vector matrix after the dimension reduction by using a KMeans clustering algorithm, and finally obtaining a clustering result of the test case. KMeans is an iteratively solved cluster analysis algorithm that randomly selects k initial cluster centers and then assigns each data point to the nearest cluster while keeping the distance of the intra-cluster object to the cluster center as small as possible.
And fifthly, grouping the test cases in the test suite based on the clustering result, and outputting all grouping test files, wherein each test file contains one grouping test case.
It will be apparent to those skilled in the art that the steps of the call dependency graph based test case clustering method of the embodiments of the present invention described above may be implemented in a general purpose computing device, they may be centralized on a single computing device, or distributed across a network of computing devices, or they may alternatively be implemented in program code executable by a computing device, such that they may be stored in a memory device for execution by the computing device and, in some cases, the steps shown or described may be performed in a different order than what is shown or described herein, or they may be separately fabricated into individual integrated circuit modules, or a plurality of modules or steps in them may be fabricated into a single integrated circuit module. Thus, embodiments of the invention are not limited to any specific combination of hardware and software.
Claims (10)
1. A test case clustering grouping method based on a call dependency graph is characterized by comprising the following steps:
step 1, firstly, carrying out static analysis on unit test case codes created by an automation tool, and constructing a call dependency graph of the test case from each assertion;
step 2, converting the call dependency graph of the test case into a graph with attributes;
step 3, calculating the similarity between the attribute-carrying graphs of the test cases by using a graph kernel-based method, and acquiring a similarity matrix of the whole test suite;
step 4, taking the similarity matrix as input, clustering the test cases based on the input matrix by using a spectral clustering algorithm, and obtaining a clustering result;
and step 5, grouping the test cases based on the clustering result, and outputting the grouped test case files.
2. The method for clustering and grouping test cases based on call dependency graphs according to claim 1, wherein in the step 1, after the test cases created by the automated test generation tool are obtained, a static analysis method is used to construct a corresponding call dependency graph, and the specific implementation process is as follows:
11 Extracting all marked @ Test annotated Test cases in the Test suite by using the Java Parser;
12 Analyzing the call dependency relationship between each assertion and other code statements in the test case;
13 Beginning with each assertion, a call dependency graph of the test case is constructed inversely from the call dependencies.
3. The test case clustering grouping method based on the call dependency graph according to claim 1, wherein in the step 2, the topology structure and the node information of the call dependency graph of the test case are analyzed, the call dependency graph is converted into a node band attribute graph, and the band attribute graph can be processed by a graph kernel tool GraKel; the specific implementation process is as follows:
21 Constructing nodes with attribute graphs, mapping the relation between the nodes in the call dependency graph to the edges of the attribute graphs, and keeping the relation between the nodes with attribute graphs consistent with the call dependency graph;
22 Extracting the object type and the name of the tested method stated in the code statement of the node in the calling dependency graph, and solving the corresponding one-hot coding feature vector to be used as the attribute value of the node with the attribute graph.
4. The test case clustering grouping method based on the call dependency graph according to claim 1, wherein in the step 3, the specific implementation process is as follows:
31 Using the shortest path graph kernel provided by GraKel to calculate the similarity between the tape attribute graphs of two test cases;
32 Calculating the similarity among all the test cases in the manner introduced in the step 31), and finally solving a similarity matrix representing the similarity relation of the whole test suite.
5. The test case clustering grouping method based on the call dependency graph according to claim 1, wherein in the step 4, a spectral clustering algorithm is used to calculate a clustering result of the test case, and the specific implementation process is as follows:
41 A similarity matrix is used as an input of a spectral clustering algorithm, and the similarity matrix can be regarded as an adjacent matrix of the graph model and is commonly used for constructing the graph model; specifically, the elements in the similarity matrix represent the degree of similarity between samples, and are regarded as edge weights in an undirected weighted graph; then, the spectral clustering algorithm calculates a Laplacian matrix and a spectral matrix based on the similarity matrix, and then obtains a characteristic value and a characteristic vector of the Laplacian matrix and the spectral matrix;
42 Firstly, arranging the characteristic values from small to large, and then selecting the characteristic vectors corresponding to the k minimum characteristic values as a characteristic vector matrix after dimension reduction, wherein each row of the matrix is the characteristic of sample mapping;
43 And finally, clustering the feature vector matrix after the dimension reduction by using a KMeans clustering algorithm, and finally obtaining a clustering result of the test case.
6. The method for clustering test cases based on call dependency graph as recited in claim 5, wherein the optimal k value is obtained by maximizing feature fracture.
7. The call dependency graph-based test case clustering grouping method according to claim 2, wherein in the step 12), the identifier is identified by defining a rule, the node is found according to the call dependency relationship, and the call dependency graph is constructed, specifically: analyzing the calling dependency relationship between each assertion and other code sentences in the test case;
121 The code expression declares the object, but the expression does not contain any other variables, and only the name of the declared object is detected to be an identifier searched by the forward node; if yes, adding the current node to the graph without updating the identifier set, and continuously searching for the subsequent node; if not, continuing to search the target node;
122 Code expression declares the object and assigns or instantiates the object by calling the constructor, using the static fields of the class instance, calling the method, and using other variables in the expression, then checking if the declared object name is the identifier that the forward node looks for; if yes, adding the current node into the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, but the identifier searched by the forward node is detected to be other variables in the expression, the current node is still added to the graph, the current identifier set is updated, and then the subsequent neighbor node is searched;
123 The code expression has only a method call and does not declare any object, and only the identifier searched by the forward node is used in the expression; if the current node is included, adding the current node to the graph, updating the current identifier set, and continuously searching for the subsequent neighbor node; if not, continuing to search for the target node.
8. The call dependency graph-based test case clustering grouping method of claim 2, wherein the step 13) constructs the call dependency graph of the test case inversely from the call dependency relationship, starting from each assertion; the definition of the nodes and edges of the call dependency graph is: the nodes comprise numbers, code sentences and successor neighbor node information; the edge represents that direct calling behavior exists between code sentences of two nodes connected with the edge; constructing a call dependency graph, namely starting from the assertion of the test case, and continuously searching for call dependency relations among code sentences until the dependency is finished; the specific implementation process is as follows:
131 Acquiring all assertion sentences in the test case code and packaging the assertion sentences into nodes, and taking the nodes as subsequent neighbor nodes of the head node;
132 Starting from each assertion node, performing an iterative process based on a work queue, wherein the initial state of the work queue only comprises the current assertion node; identifying and iterating each identifier contained in the code statement of the node in the work queue, adding the corresponding node and edge to the graph for each use and definition of the identifier, and updating the work queue and a subsequent neighbor node list of the current node; when the work queue is empty, the call dependency relationship of the assertion node is ended;
133 For each assertion node, executing the analysis process of the call dependency relationship until the call dependency relationship of all assertion nodes is finished, and completing the construction of the call dependency graph.
9. A computer device, characterized by: the computer device comprises a memory, a processor and a computer program stored on the memory and capable of running on the processor, wherein the processor realizes the test case clustering grouping method based on the call dependency graph according to any one of claims 1-8 when executing the computer program.
10. A computer-readable storage medium, characterized by: the computer-readable storage medium stores a computer program for executing the call dependency graph-based test case clustering method according to any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310459023.8A CN116560984A (en) | 2023-04-24 | 2023-04-24 | Test case clustering grouping method based on call dependency graph |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310459023.8A CN116560984A (en) | 2023-04-24 | 2023-04-24 | Test case clustering grouping method based on call dependency graph |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116560984A true CN116560984A (en) | 2023-08-08 |
Family
ID=87495742
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310459023.8A Pending CN116560984A (en) | 2023-04-24 | 2023-04-24 | Test case clustering grouping method based on call dependency graph |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116560984A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117909313A (en) * | 2024-03-19 | 2024-04-19 | 成都融见软件科技有限公司 | Distributed storage method for design code data, electronic equipment and medium |
| CN118051442A (en) * | 2024-04-15 | 2024-05-17 | 江苏省电子信息产品质量监督检验研究院(江苏省信息安全测评中心) | Test case multiplexing method and system based on spectral clustering |
-
2023
- 2023-04-24 CN CN202310459023.8A patent/CN116560984A/en active Pending
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117909313A (en) * | 2024-03-19 | 2024-04-19 | 成都融见软件科技有限公司 | Distributed storage method for design code data, electronic equipment and medium |
| CN117909313B (en) * | 2024-03-19 | 2024-05-14 | 成都融见软件科技有限公司 | Distributed storage method for design code data, electronic equipment and medium |
| CN118051442A (en) * | 2024-04-15 | 2024-05-17 | 江苏省电子信息产品质量监督检验研究院(江苏省信息安全测评中心) | Test case multiplexing method and system based on spectral clustering |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10521224B2 (en) | Automatic identification of relevant software projects for cross project learning | |
| US9569207B2 (en) | Source code flow analysis using information retrieval | |
| US10394694B2 (en) | Unexplored branch search in hybrid fuzz testing of software binaries | |
| CN101751333A (en) | Method, computer program and computer system for assisting in analyzing program | |
| CN108710662B (en) | Language conversion method and device, storage medium, data query system and method | |
| CN108170602B (en) | Test case generation method and device, terminal and computer readable medium | |
| CN116560984A (en) | Test case clustering grouping method based on call dependency graph | |
| US11288266B2 (en) | Candidate projection enumeration based query response generation | |
| CN113268485B (en) | Data table association analysis method, device, equipment and storage medium | |
| CN117273954B (en) | Stock right relation penetration method, device and equipment based on large-scale relation map | |
| CN112783513B (en) | Code risk checking method, device and equipment | |
| CN114048816A (en) | Method, device and equipment for sampling graph neural network data and storage medium | |
| CN116702157B (en) | Intelligent contract vulnerability detection method based on neural network | |
| CN112434831A (en) | Troubleshooting method and device, storage medium and computer equipment | |
| CN110580170A (en) | software performance risk identification method and device | |
| CN108830302B (en) | Image classification method, training method, classification prediction method and related device | |
| CN113419964B (en) | Test case generation method and device, computer equipment and storage medium | |
| CN114780589A (en) | Multi-table connection query method, device, equipment and storage medium | |
| Leiserson et al. | Efficient evaluation of large polynomials | |
| CN112783775A (en) | Special character input testing method and device | |
| CN112115125A (en) | Database access object name resolution method and device and electronic equipment | |
| CN112750047A (en) | Behavior relation information extraction method and device, storage medium and electronic equipment | |
| US20150142712A1 (en) | Rule discovery system, method, apparatus, and program | |
| JP2019144873A (en) | Block diagram analyzer | |
| Kimovski et al. | Autotuning of exascale applications with anomalies detection |
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 |