cyclomatic complexity = 1 + #if statements?

Question

I found the following paragraph regarding cyclomatic complexity on Wikipedia:

It can be shown that the cyclomatic complexity of any structured program with only one entrance point and one exit point is equal to the number of decision points (i.e., "if" statements or conditional loops) contained in that program plus one.

That would imply a cyclomatic complexity of 3 for two arbitrary nested if statements:

if (a)
{
    if (b)
    {
        foo();
    }
    else
    {
        bar();
    }
}
else
{
    baz();
}

Since exactly one of the three functions is going to be called, my gut agrees with 3.

However, two arbitrary if statements could also be written in sequence instead of nesting them:

if (a)
{
    foo();
}
else
{
    bar();
}

if (b)
{
    baz();
}
else
{
    qux();
}

Now there are four paths through the code:

foo, baz
foo, qux
bar, baz
bar, qux

Shouldn't the cyclomatic complexity of this fragment hence be 4 instead of 3?

Am I misunderstanding the quoted paragraph?

This exact example is discussed in the article you linked: http://en.wikipedia.org/wiki/Cyclomatic_complexity#Implications_for_software_testing — Lightness Races in Orbit, Jun 12 '14 at 18:49

score 16 · Accepted Answer · answered Jun 13 '14 at 09:11

16

Cyclomatic complexity is defined as the number of linearly independent paths through the code.

In your second example we have the following paths that runs...

| # |   A   |    B  |  Nodes hit   |
| 1 | true  | true  |  foo() baz() |
| 2 | true  | false |  foo() qux() |
| 3 | false | true  |  bar() baz() |
| 4 | false | false |  bar() qux() |

You are completely correct that the number of execution paths here is 4. And yet the cyclomatic complexity is 3.

The key is in understanding what cyclomatic complexity measures:

Definition:

A linearly independent path is any path through the program that introduces at least one new edge that is not included in any other linearly independent paths.

from http://www.ironiacorp.com/

The 4th path is not linearly independent of the first three paths, as it does not introduce any new nodes / program statements that were not included in the first three paths.

As mentioned on the wikipedia article, the cyclomatic complexity is always less than or equal to the number of theoretical unique control flow paths, and is always greater than or equal to the minimum number of actually achievable execution paths.

(to verify the second statement, imagine if b == a was always true when entering the code block you described).

answered Jun 13 '14 at 09:11

perfectionist

4,256
1
23
34

Thanks for your answer! It seems I was simply mislead into thinking that cyclomatic complexity == number of paths through the code. – fredoverflow Jun 13 '14 at 10:28
1

What if you have the path true-true and false-false, that would make it two and you would have visited all 4 nodes? What am i missing? – Captain Obvious Feb 15 '16 at 19:30
@fredoverflow can you answer please? – Captain Obvious Feb 18 '16 at 14:44
@Captain Obvious The definition of linearly independent path is stated in terms of introducing new "edges". Each new path introduces "at least one". In these terms, your example of "true-true" and "false-false", the second path introduced two new edges, so if its possible to find another path which introduces just one new edge (and it is - true-false) then you forgot to count that other path. – perfectionist Nov 01 '16 at 14:54
@fredoverflow I think what you ment is the `npath complexity`. – Daniel W. Jul 15 '21 at 13:15

score 1 · Answer 2 · answered Sep 15 '14 at 20:07

I agree with the explanation of perfectionist. Here is a more informal explanation in the case of the Java language:

McCabe's Cyclomatic Complexity (McCC) for a method is expressed as the number of independent control flow paths in it. It represents a lower bound for the number of possible execution paths in the source code and at the same time it is an upper bound for the minimum number of test cases needed for achieving full branch test coverage. The value of the metric is calculated as the number of the following instructions plus 1: if, for, foreach, while, do-while, case label (which belongs to a switch instruction), catch, conditional statement (?:). Moreover, logical “and” (&&) and logical “or” (||) expressions also add 1 to the value because their short-circuit evaluation can cause branching depending on the first operand. The following instructions are not included: else, switch, default label (which belongs to a switch instruction), try, finally.

cyclomatic complexity = 1 + #if statements?

2 Answers2