Testing Unit Coverage – Is Path Coverage Stronger Than Condition Coverage?

test-coveragetestingunit testing

I have encountered (even in literature) two contradicting opinions related to path vs condition coverage (not branch or edge!). Some say Path coverage is stronger than the condition coverage, some say the opposite.

Having code like this:

If(X<0 OR X>100)
   DoStuff();

Path coverage – 1 test case is needed to cover the path. With X=-1, the second expression will not be tested and possible bug will be missed.
Condition coverage – test cases X=-1 and X=100 are needed to test both conditions.

Am I missing something or condition coverage is really stronger than path coverage?

Condition coverage (ISTQB):

Our next level of coverage is called condition coverage. The basic concept is that, when a decision is made by a complex expression that eventually evaluates to TRUE or FALSE, we want to make sure that each atomic condition is tested both ways.

Practical Insight Into CMMI

Condition coverage measures the true and false outcome of each Boolean
subexpression.

References:

Software Testing: Principles and Practices from Srinivasan Desikan,Gopalaswamy Ramesh: page 61

Condition coverage is a much stronger criteria than path coverage,
which in turns is a much stronger criteria than statement coverage.

Best Answer

Neither one is "stronger" in the mathematical sense:

Path coverage does not imply condition coverage, as illustrated by an example in your question
Condition coverage does not imply path coverage, as illustrated by your comment (condition IF(A&&B) with pairs A=TRUE, B=FALSE and A=FALSE, B=TRUE).

This means that claims that either side is somehow "stronger" would be invalid.

If you "upgrade" the condition coverage to modified condition/decision coverage, however, the answer would be "yes": MC/DC always implies covering the path, but covering the path may not necessarily imply even covering the condition, let alone MC/DC.

However, this does not imply that 100% MC/DC is always better than path coverage: the tradeoff is that it comes at much steeper "price" than a 100% path coverage due to the need to write more tests. Sometimes, a lot more. This has a potential of complicating the maintenance of your test suite.

I think it is a good idea to maintain a good balance between condition/decision coverage and path coverage by path-covering simple conditions (such as argument checks of the "null or empty" sort) and condition/decision-covering statements with complex business logic.

Related Solutions

Condition coverage for If(A && B) – measuring the input or code exercised

Condition coverage is about testing that any operands which are part of the if expression can be evaluated to both true and false without issues. In this type of coverage, you don't care about what would be executed inside the braces, nor about the result of the operand used in a condition.

Take the following code:

bool a = ...;
bool b = ...;
if (a && b)
{
    ...
}

Condition coverage of this code would require to test:

a for both true and false, and:
b for both true and false.

In languages which require both operands to evaluate in a logical operation, condition coverage of the code above is satisfied with:

a = true; b = false
a = false; b = true

This is what is illustrated in your question.

Some languages evaluate the second operand of a logical AND only if the first operand is true (or evaluate the second operand of OR only if the first operand evaluates to false). In this case, three tests are required instead of two:

a = true; b = true
a = true; b = false
a = false

As you can note, we don't care about the value of b in the third test, since the program will never compute it when a is false.

Testing – Does Condition Coverage Subsume Edge Coverage?

Based on your definitions, it looks like edge coverage does not imply condition coverage, but condition coverage does imply edge coverage. In other words, by covering all conditions, you will be guaranteed to cover every edge; but by covering every edge, you are not guaranteed to cover every condition.

For example,

int function(int arg1, int arg2)
{
    if(arg1 < 0 || arg2 < 0)
        return -1;
    else
        return arg1 + arg2;
}

Going by edge coverage, the edges here are "return -1", and "return arg1 + arg2"; in order to cover both of those edges, you need only two invocations:

function(-1, 0); function(0, 0);

There are, however, three conditions (considering the Boolean short-circuiting logic): arg1 < 0, arg1 >= 0 && arg2 < 0, and arg1 >= 0 && arg2 >= 0, so you'd need something like the following to achieve complete condition coverage:

function(-1, 0); function(0, -1); function(0, 0);

The key distinction in the definitions you posted is "and all possible values of the constituents of compound boolean conditions are exercised at least once". Covering all the conditions will ensure that you will hit all the edges. But as you see, covering all the edges does not ensure that you will hit all the conditions.

Best Answer

Related Solutions

Condition coverage for If(A && B) – measuring the input or code exercised

Testing – Does Condition Coverage Subsume Edge Coverage?

Related Topic