Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Mccabe's Cyclomatic Complexity: Calculate with Flow Graph
Software Metric
Measurement provides a quantitative idea or indication of the size, dimension or capacity of a feature or an attribute of a software product or process. Software metric can be defined as a quantitative measure of an attribute of a software related to its cost, quality, size and schedule.
For example −
Measure − Number of Errors
Metrics − Number of Errors detected per person
Cyclomatic Complexity in Software Testing
In software testing, cyclomatic complexity of a code section is a metric, that is used to measure the complexity of a given software program. It can be defined as a quantitative measure of independent paths in the source code of the software product. It can be measured through control flow graphs or through functions, modules, methods or classes in a software program.
An independent path is that path which has at least one edge that has not been yet traversed in any other path. In 1976, Thomas J. McCabe developed the cyclomatic complexity. Cyclomatic complexity was based on the control flow representation of the software program. The control flow represents a software program in the form of a graph, that comprises of nodes and edges.
The nodes represent the processing tasks, and the edges represent the control flow between the nodes.
Flow Graph Notation for a Software Program
Flow graph notation defines the nodes that are connected through the edges. Following are the flow diagrams for if-else, while statements and normal sequence of flow.
How to calculate Cyclomatic Complexity
Mathematical representation − Cyclomatic complexity is a set of independent paths through the graph diagram. It is represented through the formula −
V(G) = E – N + 2, where E = number of edges, N = number of nodes
Or,
V(G) = P + 1, where P = number of predicate nodes, that contain condition
Properties of Cyclomatic Complexity
V(G) denotes the maximum number of independent paths represented through the graph.
V(G) > 1
If V(G) = 1, i.e., V(G) is unity, then G can have only one path.
Reduce the complexity to 10.
How is Cyclomatic Complexity useful for software testing?
Basis path testing is a technique used in White Box testing to ensure the execution of at least one statement during software testing. Cyclomatic complexity assesses all the linearly independent paths through the program, i.e., the number of test cases will be equal to the cyclomatic complexity of the software program. It is useful due to its properties of cyclomatic complexity (M) −
M is the number of test cases required to achieve branch coverage (called upper bound).
Or, M can be the number of paths, including the independent paths, through the graphs (called lower bound).
Procedure for Computing Cyclomatic Complexity and Designing Test Cases
Construct a graph with nodes and edges from the software code.
Identify the independent paths.
If V(G) = 1, i.e., V(G) is unity, then G can have only one path.
Design the test cases.
After the basic set has been formed, the test cases must be written to implement each path.
V(G) − Cyclomatic complexity can also be manually calculated provided that the software program is small. Automated tool, that are required to if the program is too complex, because it involves more flow graphs. On the basis of the complexity number, the project team decide upon the actions that need to be implemented for measure.
The table below provides an overview of the complexity number and corresponding meaning of V(G) −
| Complexity | Meaning |
|---|---|
| 1 – 10 | Structured, well written code
High testability
Less cost and effort |
| 10 – 20 | Complex code Medium testability Medium cost and effort |
| 20 – 40 | Too complex code
Low testability
High cost and effort |
| > 40 | Cannot be tested
Very high cost and effort |
Tools for calculating Cyclomatic Complexity
There are many tools available in the global market, that are used to determine the complexity of the software product or application. Some tools are used for certain technologies. Complexity can be determined by the number of decision points in the software program. For example, if, for, for-each, while, do, catch, case statements in a source code.
Some of the tools for calculating cyclomatic complexity are −
OClint
This is a static code analysis tool used to improve the quality of the software product and also to reduce the defects by investigating the C, C++, Objective-C code, and by finding out possible problems like −
Possible bugs − if, else, try, catch, finally statements
Unused code − This includes local variables and parameters that are unused.
Complicated code − This includes very high cyclomatic complexity, NPath complexity and very high NCSS.
Redundant code − This includes redundant if statements, useless parentheses, etc.
Code smells − This includes long methods and long parameter lists.
Bad practices − This includes inverted logic and parameter assignment.
With OClint, we can automate the inspection process with advanced features −
Dependency on the abstract syntax tree of the source code of the software for better accuracy and efficacy. The false positives are reduced to prevent useful results from sinking in them.
It enables the dynamic loading of rules into the system, even during the runtime.
It offers agile and extensible configurations to make sure that the users in customizing the behaviours of the tool.
Its command line invocation enables Continuous Integration (CI) and continuous inspection of the software code, so that the technical debts can be settled as early as possible to reduce the cost spent on maintenance.
GTMetrix
This tool is used to analyse the loading speed of pages and their performance. It provides scores for our pages and Pagespeed along with WiSlow. It is an open-source tool, used to get detailed reports about the site performance. It also provides recommendations for improving the scores of the web pages. It also helps us run analytics from the WordPress.
It also helps us schedule daily, weekly, or monthly reports. It also notifies us about the status of the website from a WordPress admin. First, we need to create a GTMetrix account. The account is free for a limited time and to some number of requests per day.
Reflector Add In
This tool is used for code metric for .NET assemblies.
Use of Cyclomatic Complexity
It also guides the testing process, and is easy to apply.
It also helps developers assure their clients that all the paths have been tested thoroughly.
It helps emphasize more on the uncovered paths.
It helps emphasize more on the uncovered paths.
Cyclomatic complexity metric helps increase the code coverage.
It helps estimate the risk in the application or software program.
Metrics help reduce more risk of the program, if used early.
Advantages of Cyclomatic Complexity
Cyclomatic complexity can be used as a quality metric.
It provides relative complexity of various designs.
It can computer fast than the Halstead’s metrics.
Cyclomatic complexity is also used to measure the minimum effort and the best areas of concentration.
It also guides the testing process, and is easy to apply.
Disadvantages of Cyclomatic Complexity
Cyclomatic complexity is the measure of the control complexity of the software program instead of the data complexity.
The nested conditional structures are much harder and complex to analyse than he non-tested structures.
For simple comparisons and decision structures, cyclomatic complexity may give a misleading figure.
Conclusion
Cyclomatic complexity is a software metric technique. It is used for structured or White Box testing. It is primarily used for evaluating complexity of the software program. The complexity of the software program increases, if it has more decision points. For software programs with high complexity, the probability of the error increases with time, for maintenance and trouble shoot.
3K+ Views
