CN109814924B - Software complexity calculation method - Google Patents
Software complexity calculation method Download PDFInfo
- Publication number
- CN109814924B CN109814924B CN201910081440.7A CN201910081440A CN109814924B CN 109814924 B CN109814924 B CN 109814924B CN 201910081440 A CN201910081440 A CN 201910081440A CN 109814924 B CN109814924 B CN 109814924B
- Authority
- CN
- China
- Prior art keywords
- software
- complexity
- component
- path
- execution
- 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
Images
Abstract
The invention discloses a software complexity calculation method, which comprises the following steps: acquiring each activity included by a component in the software; executing each component in the software by operating semantic rules according to each activity included by the component to obtain path information corresponding to the execution path of the software; and calculating the complexity of the software according to the path information corresponding to the execution path of the software. The invention provides a modeling language facing to complexity, and designs an operation semantic rule for the modeling language, and can measure the complexity of a software product at each stage of software development based on the modeling language and the operation semantic rule, and not only can calculate the dynamic complexity of a component, but also can calculate the average complexity of a software structure, thereby improving the accuracy of software complexity calculation.
Description
Technical Field
The invention mainly relates to the technical field of software, in particular to a software complexity calculating method.
Background
With the rapid development of computer and internet technologies, the development prospects in the fields of artificial intelligence, machine learning, cloud computing and the like are wider and wider, and application systems developed by using the technologies are wider and wider, and meanwhile, the life style of people is also continuously changed. Software systems continue to scale and become more and more complex in their functionality. Due to continuous innovation of software technology, people have higher and higher requirements on software functions, so that the software is required to realize powerful functions, and the requirements on quality attributes such as reliability, stability and the like of software products are higher and higher, so that the evaluation work on the software quality becomes more and more important.
In software development, software complexity is an important factor affecting software quality and is therefore an aspect of particular interest to developers. The complexity of the software is too high, which may result in the degradation of the quality level of the software, such as efficiency, maintainability, testability, reliability, etc., and at the same time, may increase the risk of the software, which has a very significant threat to the field with extremely high software quality requirements. The quality of the software is an important evaluation factor for ensuring whether the software can be used for a long time with few errors or even no errors.
Currently, the common complexity measurement methods include: code line number mode, circle complexity mode and Halstead complexity mode. The code line number mode is used for measuring the size of the software scale according to the line number of the software code. The larger the number of code lines, the more complex the software. However, the method has great one-sidedness, only can be roughly evaluated, and the evaluation result is inaccurate. The circle complexity is mainly used for measuring the complexity of a module structure, the number of independent paths is calculated, the complexity of different kinds of control flows is not distinguished, and the complexity of sequential statements is not considered. The Halstead complexity takes operators and operands appearing in a program as counting objects, and takes the times of the appearance of the operators and the operands as counting targets, so as to calculate the capacity and the workload of the program. But the problem of complexity of interaction among all modules is not solved, and errors exist.
From the above, the existing software complexity calculation mode generally has the problems of low accuracy and large error.
Disclosure of Invention
In order to solve the problems, the invention provides a software complexity calculating method, provides a modeling language oriented to complexity, designs an operation semantic rule for the modeling language, can measure the complexity of a software product at each stage of software development based on the modeling language and the operation semantic rule, and can calculate the dynamic complexity of a component and the average complexity of a software structure.
Specifically, the invention provides a software complexity calculation method, which comprises the following steps:
acquiring each activity included by a component in the software;
executing each component in the software by operating semantic rules according to each activity included by the component to obtain path information corresponding to the execution path of the software;
and calculating the complexity of the software according to the path information corresponding to the execution path of the software.
Preferably, the acquiring of the activities included by the components in the software comprises:
abstracting component information corresponding to components included in software through a complexity-oriented modeling language;
identifying, from the building information, each activity that the building comprises, the activity consisting of a duplet comprising a function to which the activity corresponds and a complexity of performing the function.
Preferably, the executing each component in the software by operating a semantic rule according to each activity included in the component to obtain path information corresponding to an execution path of the software includes:
determining component combination relations among the components in the software through a complexity-oriented modeling language;
executing the software according to the execution rule of the component combination relation through the operation semantic rule;
and recording path information corresponding to each execution path in the software executing process, wherein the path information comprises each activity included in the execution path.
Preferably, the calculating the complexity of the software according to the path information corresponding to the execution path of the software includes:
and calculating the sum of the complexity of each activity included in the path information corresponding to the execution path, and taking the obtained sum as the dynamic complexity of the software under the execution path.
Preferably, the calculating the complexity of the software according to the path information corresponding to the execution path of the software includes:
respectively calculating the sum of the complexity of each activity included in the path information corresponding to each execution path to obtain the path complexity corresponding to each execution path;
and calculating the average complexity of the software according to the path complexity corresponding to each execution path.
Preferably, the calculating the average complexity of the software according to the path complexity corresponding to each execution path includes:
and calculating the sum of the path complexity corresponding to each execution path, calculating the ratio between the sum and the total number of the execution paths, and taking the ratio as the average complexity of the software.
Further, the method further comprises:
if the complexity of the software is greater than a preset threshold value, determining the complexity of each component combination included in the software;
and optimizing the structure of the software according to the complexity of each component combination until the complexity of the software is less than or equal to the preset threshold.
Preferably, the optimizing the structure of the software according to the complexity of each component combination until the complexity of the software is less than or equal to the preset threshold includes:
determining a first component combination with the highest complexity from the component combinations;
acquiring a second component combination, wherein the similarity between the functions of the second component combination and the functions of the first component combination is greater than a preset value, and the complexity of the second component is less than that of the first component combination;
replacing the first member combination with the second member combination;
and recalculating the complexity of the software, and if the complexity of the software is still greater than the preset threshold, returning to execute the operation of determining the first component combination with the maximum complexity from the component combinations until the complexity of the software is less than or equal to the preset threshold.
Further, the method further comprises:
a block diagram of the software is shown in graphical form, the block diagram including components of the software and activities performed by each component.
Further, the method further comprises:
in the graphically displayed structure diagram of the software, the complexity of each component and/or each activity occurring during execution is noted.
Compared with the existing software complexity evaluation technology, the software complexity calculation method has the following beneficial effects:
the embodiment of the invention provides a modeling language oriented to complexity, and designs an operation semantic rule for the modeling language, so that a software structure can be described more clearly, and the operation semantic can describe the complexity change condition in the execution process very strictly. Based on the modeling language and the operation semantic rule, the complexity of a software product can be measured at each stage of software development, the dynamic complexity of a component can be calculated, the average complexity of a software structure can be calculated, and the accuracy of software complexity calculation is improved. On the basis of calculating the software complexity, an algebraic method is used for further researching the evolution problem of the software structure, and the purpose is to optimize the software structure and reduce the complexity of the software structure. And also provides a graphical representation method of the modeling language, so that a developer can be more clear to the structure of the software, and the graphical representation method can also indicate the complexity generated in the process of executing each component or activity.
Drawings
Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiments. The drawings are only for purposes of illustrating the preferred embodiments and are not to be construed as limiting the invention. Also, like reference numerals are used to refer to like parts throughout the drawings. In the drawings:
fig. 1 is a schematic diagram showing the components of a software structure provided by the embodiment of the present invention.
Fig. 2 is a flowchart illustrating a software complexity calculating method according to an embodiment of the present invention.
Fig. 3 is a flow chart of another software complexity calculation method provided by the embodiment of the invention.
Detailed Description
Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
In the embodiment of the present invention, a complexity-oriented modeling language is provided, and based on component development, a software structure is abstracted, such as a composition diagram of the software structure shown in fig. 1. The modeling language describes a software product by movably composing components that make up the software structure. The modeling language is used for describing the functions and the complexity of the software structure, so that the relationship among component combinations and the change situation of the complexity in the execution process can be more clearly understood.
The embodiment of the invention also provides an operation semantic rule for the modeling language, and the operation semantic rule can describe the change situation of the complexity of the component in the execution process very strictly, so the operation semantic rule of the modeling language is used for specifying the rule executed by the component combination and the complexity generated in the execution process.
Based on the complexity-oriented modeling language and the operation semantic rule, the embodiment of the invention provides a novel software complexity calculating method, which can calculate the complexity of software according to the path information executed by a component, and can calculate the dynamic complexity of the software and the average complexity of the whole software structure.
Referring to fig. 2, the embodiment of the present invention specifically calculates the complexity of the software through the following operations 101-103, including:
step 101: various activities included by the components in the software are acquired.
Specifically, component information corresponding to components included in the software is abstracted through a complexity-oriented modeling language; and identifying each activity included by the member from the member information, wherein the activity consists of a binary group, and the binary group comprises a function corresponding to the activity and the complexity generated by executing the function.
The modeling language facing complexity refers to using formalization method and abstracting the information of the building block, the specified building block is composed of activities, the activities are composed of a bituple, namely, the activities are composed of the functions of the activities and the complexity needed for executing the functions. Activity is the smallest unit of a constituent member. The building blocks are basic units for forming the software structure, abstract the software structure in the newly proposed modeling language, and the building blocks are the most important parts for forming the software structure.
The formalization method is a method for solving problems in the field of software engineering by using a mathematical logic reasoning method, and is an important way for ensuring the design correctness of a software system. Wherein algebra, logic, automata, etc. form the theoretical basis of the formalization method. The formalization realizes modeling and analysis of the system style and the structural style. Using formalization methods can eliminate ambiguity at the development stage, allowing all design work to follow some mathematical theory. Furthermore, formalization methods facilitate machine expression and computation by using rigorous mathematical representations. Complexity-oriented modeling language: the invention uses formalization to define a group of grammar rules for describing the components and the component combination, and specifies that the activity is the minimum unit for forming the components, and the combination of the components forms a software structure; the modeling language mainly specifies the combination relationship among components such as sequence, concurrence, selection, calling and the like.
Step 102: and according to each activity included by the component, operating each component in the software by operating the semantic rule to obtain the path information corresponding to the execution path of the software.
The operation semantic rules define execution rules for the combination relations of sequence, concurrency, selection, calling and the like according to the characteristics of the modeling language, the operation semantic rules specify the execution rules of functions and the complexity change caused by the combination relations, the complexity generated by the combination relations among the components is displayed through the operation semantic rules, and the complexity change condition of each component in the execution process can be known more clearly.
The operation semantic rules specify execution rules for the component composition relationships and the computation of the complexity resulting from the component composition relationships. According to the operation semantic rule, the complexity required by the component in the execution process can be calculated, and the path information of the component execution process can be tracked.
Specifically, the component combination relationship among the components in the software is determined through a complexity-oriented modeling language, and the component combination relationship comprises sequential, concurrent, selection and calling relationships. Operating software according to an execution rule of the component combination relation by operating a semantic rule; and recording path information corresponding to each execution path in the software running process, wherein the path information comprises each activity included in the execution path.
Step 103: and calculating the complexity of the software according to the path information corresponding to the execution path of the software.
According to the operation semantic rule, the path information generated by the member in the execution process can be recorded, and the path not only contains all functions executed by the member, but also contains the information of the complexity of executing the functions and the combination relationship among the members, so that the complexity required by the member in the execution process can be calculated according to the path information.
By the calculation method provided by the embodiment of the invention, the dynamic complexity of the software can be calculated, and the average complexity of the software can also be calculated. The path information of the execution path includes the activities included in the execution path, and the activities are represented by two-tuples consisting of functions and complexity. Due to different component combination relations among the components in the software, the different component combination relations may cause a plurality of execution paths in the software running process. Therefore, for the dynamic complexity, the sum of the complexity of each activity included in the path information corresponding to the execution path is calculated, and the obtained sum value is used as the dynamic complexity of the software under the execution path. In this way, the dynamic complexity of the software corresponding to each execution path can be obtained.
Respectively calculating the sum of the complexity of each activity included in the path information corresponding to each execution path according to the average complexity of the software product to obtain the path complexity corresponding to each execution path; and calculating the average complexity of the software according to the path complexity corresponding to each execution path.
When the average complexity of the software is calculated according to the path complexity corresponding to each execution path, specifically, the sum of the path complexities corresponding to each execution path is calculated, the ratio between the obtained sum and the total number of the execution paths is calculated, and the ratio is used as the average complexity of the software.
In the embodiment of the invention, in the software development process, the software structure is built into components by activities, and then the components finally form the whole software structure, the whole process is a dynamic development process, and the software contains more and more activities or components along with the continuous promotion of the development process. The embodiment of the invention is a component-based complexity calculation method, and the dynamic complexity or the average complexity of a software product can be measured in the above mode at each stage of software development.
According to the mode, the embodiment of the invention can calculate the dynamic complexity of the software and the average complexity of the whole software structure, can help to evaluate the software complexity condition under the current condition in the software development process, can make proper adjustment according to the complexity to develop a more optimized software product, can research the evolution problem of the software structure by using an algebraic method, and provides some algebraic rules to help to optimize the software structure.
And if the complexity of the software is greater than the preset threshold, the complexity of the current software is over high, and the software structure needs to be optimized. Specifically, the complexity of each component combination included in the software is determined, the component combination can be embodied by a component combination relation among a plurality of components, and the component combination relation can be a sequence, concurrence, selection and calling relation. By operating the semantic rules, the complexity of each component combination can be determined according to the execution rules of the component combination relationship. And then optimizing the structure of the software according to the complexity of each component combination until the complexity of the software is less than or equal to the preset threshold.
Specifically, a first component combination with the highest complexity is determined from the component combinations; acquiring a second component combination, wherein the similarity between the functions of the second component combination and the functions of the first component combination is greater than a preset value, and the complexity of the second component is less than that of the first component combination; replacing the first member combination with a second member combination; and recalculating the complexity of the software, if the complexity of the software is still greater than the preset threshold value, determining the first component combination with the maximum complexity from all the component combinations again, and replacing the first component combination according to the mode until the complexity of the software is less than or equal to the preset threshold value.
In an embodiment of the invention, a block diagram of the software is also shown in a graphical form, the block diagram including various components in the software and various activities that each component includes. Further, the complexity of each component and/or each activity occurring during its execution may also be noted in the graphically displayed block diagram of the software.
The embodiment of the invention is carried out on the basis of component development, a formalization method is used for providing a complexity-oriented modeling language, and a graphical representation method of the language is also provided, so that a developer can be more clear to the structure of software, and the graphical representation method can also indicate the complexity generated in the execution process of each component or activity. The modeling language analyzes the combinatorial relationships between the building blocks and separates the combinatorial relationships into sequential, concurrent, selection and invocation relationships. And specifies the impact that these relationships have on the complexity of the software. Meanwhile, a set of executed operation semantic rules is designed for the modeling language, so that the software structure can be described more clearly. The operation semantic rules can describe the change of complexity in the execution process very strictly.
As shown in fig. 3, the embodiment of the present invention provides a complexity-oriented modeling language, designs an operation semantic rule for the modeling language, calculates software complexity based on the modeling language and the operation semantic rule, and optimizes a software structure based on the calculated software complexity.
The embodiment of the invention can simulate the execution of the component according to the operation semantic rule, record all the activities executed by the component and the generated complexity in the process, save all the information executed by the component through the recording mode, extract all the complexity information in the execution process according to the path information executed by the component, and obtain the complexity of the component or the software structure. The invention can calculate different complexity according to the difference of the path length, namely the dynamic complexity of the component can be calculated, and the average complexity of the whole software structure can also be calculated. On the basis of calculating the software complexity, an algebraic method is used for further researching the evolution problem of the software structure, and the purpose is to optimize the software structure and reduce the complexity of the software structure.
In the embodiment of the invention, a modeling language oriented to complexity is provided, and an operation semantic rule is designed for the modeling language, so that a software structure can be described more clearly, and the operation semantic can describe the complexity change condition in the execution process very strictly. Based on the modeling language and the operation semantic rule, the complexity of a software product can be measured at each stage of software development, the dynamic complexity of a component can be calculated, the average complexity of a software structure can be calculated, and the accuracy of software complexity calculation is improved. On the basis of calculating the software complexity, an algebraic method is used for further researching the evolution problem of the software structure, and the purpose is to optimize the software structure and reduce the complexity of the software structure. And also provides a graphical representation method of the modeling language, so that a developer can be more clear to the structure of the software, and the graphical representation method can also indicate the complexity generated in the process of executing each component or activity.
It should be noted that:
the algorithms and displays presented herein are not inherently related to any particular computer, virtual machine, or other apparatus. Various general purpose devices may be used with the teachings herein. The required structure for constructing such a device will be apparent from the description above. Moreover, the present invention is not directed to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the present invention as described herein, and any descriptions of specific languages are provided above to disclose the best mode of the invention.
In the description provided herein, numerous specific details are set forth. It is understood, however, that embodiments of the invention may be practiced without these specific details. In some instances, well-known systems, structures, and techniques have not been shown in detail in order not to obscure an understanding of this description.
Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the invention, various features of the invention are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure and aiding in the understanding of one or more of the various inventive aspects. However, the disclosed system should not be interpreted to reflect the intent: that the invention as claimed requires more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive aspects lie in less than all features of a single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into this detailed description, with each claim standing on its own as a separate embodiment of this invention.
Those skilled in the art will appreciate that the steps in the devices of the embodiments may be adaptively changed and arranged in one or more devices different from the embodiments. Steps or components in the embodiments may be combined into one step or component, and further, may be divided into a plurality of steps or sub-components. All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and all of the processes or steps of any system or apparatus so disclosed, may be combined in any combination, except combinations where at least some of such features and/or processes or steps are mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.
Furthermore, those skilled in the art will appreciate that while some embodiments described herein include some features included in other embodiments, rather than other features, combinations of features of different embodiments are meant to be within the scope of the invention and form different embodiments. For example, in the following claims, any of the claimed embodiments may be used in any combination.
The various component embodiments of the invention may be implemented in hardware, or in software steps running on one or more processors, or in a combination thereof. Those skilled in the art will appreciate that a microprocessor or Digital Signal Processor (DSP) may be used in practice to implement some or all of the functions of some or all of the components in the creation apparatus of a virtual machine according to embodiments of the present invention. The present invention may also be embodied as apparatus or device programs (e.g., computer programs and computer program products) for performing a portion or all of the system described herein. Such programs implementing the present invention may be stored on computer-readable media or may be in the form of one or more signals. Such a signal may be downloaded from an internet website or provided on a carrier signal or in any other form.
It should be noted that the above-mentioned embodiments illustrate rather than limit the invention, and that those skilled in the art will be able to design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the step claims enumerating several means, several of these means may be embodied by one and the same item of hardware. The usage of the words first, second and third, etcetera do not indicate any ordering. These words may be interpreted as names.
The above description is only for the preferred embodiment of the present invention, but the scope of the present invention is not limited thereto, and any changes or substitutions that can be easily conceived by those skilled in the art within the technical scope of the present invention are included in the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the appended claims.
Claims (9)
1. A software complexity calculation method, comprising:
acquiring each activity included by a member in software, wherein each activity included by the member is identified from member information through the member information corresponding to the member included by the complexity-oriented modeling language abstract software, the activity is composed of a couple including a function corresponding to the activity and a complexity generated by executing the function;
executing each component in the software by operating semantic rules according to each activity included by the component to obtain path information corresponding to the execution path of the software;
and calculating the complexity of the software according to the path information corresponding to the execution path of the software.
2. The method according to claim 1, wherein the executing each component in the software by operating semantic rules according to each activity included in the component to obtain path information corresponding to an execution path of the software comprises:
determining component combination relations among the components in the software through a complexity-oriented modeling language;
operating the software according to the execution rule of the component combination relationship through the operation semantic rule;
and recording path information corresponding to each execution path in the software running process, wherein the path information comprises each activity included in the execution path.
3. The method according to claim 1, wherein the calculating the complexity of the software according to the path information corresponding to the execution path of the software comprises:
and calculating the sum of the complexity of each activity included in the path information corresponding to the execution path, and taking the obtained sum as the dynamic complexity of the software under the execution path.
4. The method according to claim 1, wherein the calculating the complexity of the software according to the path information corresponding to the execution path of the software comprises:
respectively calculating the sum of the complexity of each activity included in the path information corresponding to each execution path to obtain the path complexity corresponding to each execution path;
and calculating the average complexity of the software according to the path complexity corresponding to each execution path.
5. The method of claim 4, wherein the calculating the average complexity of the software according to the path complexity corresponding to each execution path comprises:
and calculating the sum of the path complexity corresponding to each execution path, calculating the ratio between the sum and the total number of the execution paths, and taking the ratio as the average complexity of the software.
6. The method according to any one of claims 1-5, further comprising:
if the complexity of the software is greater than a preset threshold value, determining the complexity of each component combination included in the software;
and optimizing the structure of the software according to the complexity of each component combination until the complexity of the software is less than or equal to the preset threshold.
7. The method according to claim 6, wherein the optimizing the structure of the software according to the complexity of each component combination until the complexity of the software is less than or equal to the preset threshold value comprises:
determining a first component combination with the highest complexity from the component combinations;
acquiring a second component combination, wherein the similarity between the functions of the second component combination and the functions of the first component combination is greater than a preset value, and the complexity of the second component is less than that of the first component combination;
replacing the first member combination with the second member combination;
and recalculating the complexity of the software, and if the complexity of the software is still greater than the preset threshold, returning to execute the operation of determining the first component combination with the maximum complexity from the component combinations until the complexity of the software is less than or equal to the preset threshold.
8. The method according to any one of claims 1-5, further comprising:
a block diagram of the software is shown in graphical form, the block diagram including components of the software and activities performed by each component.
9. The method of claim 8, further comprising:
in the graphically displayed structure diagram of the software, the complexity of each component and/or each activity occurring during execution is noted.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910081440.7A CN109814924B (en) | 2019-01-28 | 2019-01-28 | Software complexity calculation method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910081440.7A CN109814924B (en) | 2019-01-28 | 2019-01-28 | Software complexity calculation method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109814924A CN109814924A (en) | 2019-05-28 |
| CN109814924B true CN109814924B (en) | 2020-10-02 |
Family
ID=66605574
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910081440.7A Active CN109814924B (en) | 2019-01-28 | 2019-01-28 | Software complexity calculation method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109814924B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110825350A (en) * | 2019-09-16 | 2020-02-21 | 北京银企融合技术开发有限公司 | Method and system for changing functional requirements of software product |
| CN110688152B (en) * | 2019-09-27 | 2021-01-01 | 厦门大学 | Software reliability quantitative evaluation method combining software development quality information |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105468521A (en) * | 2015-11-18 | 2016-04-06 | 北京航空航天大学 | Pointer related semantic error location method based on subgraph search |
| CN108509336A (en) * | 2018-03-05 | 2018-09-07 | 华东师范大学 | A kind of operating system canonical form chemical examination card and test method |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160042180A1 (en) * | 2014-08-07 | 2016-02-11 | Ut Battelle, Llc | Behavior specification, finding main, and call graph visualizations |
| CN107391124B (en) * | 2017-06-30 | 2020-06-16 | 东南大学 | Conditional slicing method based on golden section search and software execution track |
-
2019
- 2019-01-28 CN CN201910081440.7A patent/CN109814924B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105468521A (en) * | 2015-11-18 | 2016-04-06 | 北京航空航天大学 | Pointer related semantic error location method based on subgraph search |
| CN108509336A (en) * | 2018-03-05 | 2018-09-07 | 华东师范大学 | A kind of operating system canonical form chemical examination card and test method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109814924A (en) | 2019-05-28 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP3816806A1 (en) | Utilizing neural network and artificial intelligence models to select and execute test cases in a software development platform | |
| CN102521123B (en) | A kind of embedded software test pile pitching method of logic-based execution block | |
| US20080320457A1 (en) | Intermediate Code Metrics | |
| CN100356341C (en) | Method for estimating power consumption when embedded software running based on simulator | |
| US8843900B2 (en) | Serial debugging experience for parallel programs | |
| US20090217246A1 (en) | Evaluating Software Programming Skills | |
| US11816017B2 (en) | Systems and methods for evaluating code contributions by software developers | |
| US20220122739A1 (en) | Ai-based condition classification system for patients with novel coronavirus | |
| US20140019941A1 (en) | Data selection | |
| CN109814924B (en) | Software complexity calculation method | |
| JP6342129B2 (en) | Source code error position detection apparatus and method for mixed mode program | |
| Nusrat et al. | How developers optimize virtual reality applications: A study of optimization commits in open source unity projects | |
| CN108228187A (en) | A kind of global optimization method of mathematical program | |
| El Mandouh et al. | Application of machine learning techniques in post-silicon debugging and bug localization | |
| CN106933572B (en) | Measurement model based on LLVM intermediate representation program slice | |
| CN105243023A (en) | Method for detecting errors generated during parallel running | |
| CN102520984B (en) | Computing method for worst time of object software in specified hardware environment | |
| CN109815148B (en) | Software complexity computing system | |
| CN114168565B (en) | Backtracking test method, device and system of business rule model and decision engine | |
| Wienke et al. | Performance regression testing and run-time verification of components in robotics systems | |
| WO2022061779A1 (en) | Change correlation analysis-based test case selection method and apparatus | |
| CN109710538B (en) | Static detection method for state-related defects in large-scale system | |
| CN115543719B (en) | Component optimization method and device based on chip design, computer equipment and medium | |
| CN117785681A (en) | Test case complement method and device | |
| JP2007323299A (en) | Apparatus and program for determining review execution order, recording medium with the program stored, and method for determining review execution order |
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 |