A difference between statement and decision coverage

The answer by Paul isn't quite right, at least I think so (according to ISTQB's definitions). There's quite significant difference between statement, decision/branch and condition coverage. I'll use the sample from the other answer but modified a bit, so I can show all three test coverage examples. Tests written here gives 100% test coverage for each type.

if(a || b)) {
    test1 = true;
}
else {
    if(c) {
      test2 = true
    }
}

We have two statements here - if(a||b) and if(c), to fully explain those coverage differences:

1. statement coverage have to test each statement at least once, so we need just two tests:
   • a=true b=false - that gives us path if(a||b) true -> test1 = true
   • a=false, b=false and c=true - that gives us path: if(a||b) false -> else -> if(c) -> test2=true.

This way we executed each and every statement.

2. branch/decision coverage needs one more test:

   • a=false, b=false, c=false - that leads us to that second if but we are executing false branch from that statement, that wasn't executed in statement coverage

   That way we have all the branches tested, meaning we went through all the paths.

3. condition coverage needs another test:

   • a=false, b=true - that leads through the same path as first test but executes the other decision in OR statement (a||b) to go through it.

That way we have all conditions tested, meaning that we went through all paths (branches) and triggered it with each condition we could - first 'if' statement was true in first test because of a=true triggered it and in the last test because b=true triggered it. Of course someone can argue that case with a=true and b=true should be tested as well, but when we will check how 'or' works then we can see it isn't needed and also variable c can be of any value as in those tests it is not evaluated.

At least I interpreted it this way. If someone is still interested :)

EDIT: In most sources I found lately decision/branch coverage terms are equivalent and the term I described as decision coverage is in fact condition coverage hence that update of the answer.

Nice question. The explanation I often use is that an if-statement without an else-branch still has an invisible "empty" else-statement:

• Plain statement coverage just insists that all statements that are actually there are really executed.

• Branch coverage insists that even invisible else-branches are executed.

Similar situations occur with switch-statements without a default-case, and repeat-until loops. Branch coverage requires that a default-case is executed, and that a repeat-until is executed at least twice.

A code example:

if (passwordEnteredOK()) {
    enterSystem();
} 
/* Invisible else part 
else {
  // do nothing
}
*/

With statement coverage you just check that with a correct password you can use the system. With branch coverage you also test that with an incorrect password you will not enter the system.

If the tests have complete branch coverage then we can say it also has complete statement coverage, but not the vice versa.

100% branch coverage => 100% statement coverage

100% statement coverage does not imply 100% branch coverage

the reason is in branch coverage apart from executing all the statements, we should also verify if the tests executes all branches, which can be interpreted as covering all edges in the control flow branch

if(a){
   if(b){
     bool statement1 = true;
   }
}

a = true, b = true will give 100% statement coverage, but not branch coverage

In the branch coverage we need to cover all the edges, which we missed in the statement coverage shown as red lines in the above image