La copertura del percorso è più strong della copertura delle condizioni?

Nessuno dei due è "più strong" in senso matematico:

• La copertura del percorso non implica la copertura delle condizioni, come illustrato da un esempio nella tua domanda
• La copertura delle condizioni non implica la copertura del percorso, come illustrato dal tuo commento (condizione IF(A&&B) con coppie A=TRUE, B=FALSE e A=FALSE, B=TRUE ).

Questo significa che affermare che entrambe le parti sono in qualche modo "più forti" non sarebbe valido.

Se "aggiorna" la copertura delle condizioni a condizione modificata / copertura decisionale , tuttavia, la risposta sarebbe "sì": MC / DC implica sempre la copertura del percorso, ma coprire il percorso potrebbe non implicare necessariamente anche la copertura della condizione, per non parlare di MC / DC.

Tuttavia, questo non implica che il 100% MC / DC sia sempre migliore della copertura del percorso: il compromesso è che si tratta di un "prezzo" molto più ripido di una copertura del percorso del 100% a causa della necessità di scrivere più test. A volte, molto di più. Questo potrebbe complicare la manutenzione della tua suite di test.

Penso che sia una buona idea mantenere un buon equilibrio tra copertura delle condizioni / decisione e copertura del percorso in base a condizioni semplici (come la verifica degli argomenti del tipo "nullo o vuoto") e le istruzioni sulla condizione / decisione con una logica aziendale complessa.

La copertura del percorso è strettamente più completa della copertura della filiale.

Un esempio estratto da Wikipedia :

two properties of the cyclomatic complexity, M, for a specific module:

• M is an upper bound for the number of test cases that are necessary to achieve a complete branch coverage.
• M is a lower bound for the number of paths through the control flow graph (CFG).

if( c1() )
   f1();
else
   f2();

if( c2() )
   f3();
else
   f4();

In this example, two test cases are sufficient to achieve a complete branch coverage, while four are necessary for complete path coverage. The cyclomatic complexity of the program is 3 (as the strongly connected graph for the program contains 9 edges, 7 nodes and 1 connected component) (9-7+1).

Tuttavia, come notato un po 'più in basso (il mio in grassetto per enfasi):

Unfortunately, it is not always practical to test all possible paths through a program. Considering the example above, each time an additional if-then-else statement is added, the number of possible paths doubles. As the program grew in this fashion, it would quickly reach the point where testing all of the paths was impractical.

Modifica

Ok, penso di vedere da dove proviene @ user970696 nei commenti. Se ho capito bene, la risposta è ancora la copertura del percorso rigorosamente. L'unica volta che avrai un risultato "speciale" diverso dalla copertura delle filiali è quando vengono chiamate le funzioni nel condizionale, che possono essere eseguite o meno a causa del cortocircuito.

Ma quando ciò accade, contano come parte del percorso.

Prendi questo, ad esempio:

if (a() && b()):
   foo()
else:
   bar()

• La copertura della filiale ha 2 casi:
  • (a () & & b ()) == True
  • (a () & & b ()) == False
• La copertura condizionale ha 3 casi:
  • a () == Falso
  • a () == True & & b () == False
  • a () == True & & b () == True
• La copertura del percorso ha gli stessi 3 casi:
  • Percorso: a (), bar ()
  • Percorso: a (), b (), bar ()
  • Percorso: a (), b (), foo ()

Tuttavia, quando aggiungi una seconda istruzione if , come menzionato sopra, il numero di percorsi si moltiplica, mentre ogni singola istruzione if rimane con la stessa complessità.

La principale differenza tra copertura delle condizioni e copertura del percorso è che la copertura delle condizioni è locale per alcune strutture di controllo (se, mentre, per, ...), mentre la copertura del percorso è globale per l'intero programma e quindi include tutte le possibili combinazioni di rami (non condizioni).

Dal punto di vista locale, la copertura delle condizioni è più strong.

Dal punto di vista globale, la copertura del percorso è più strong. Così più strong che di solito non è realizzabile.

La copertura del percorso include fondamentalmente la copertura delle affermazioni nel programma che hai scritto. Questo è se il programma contiene le seguenti righe di codice come: 1. se (condizione 1) 2. quindi chiama una funzione; 3. altro 4. chiama quella funzione; 5. chiama un'altra funzione; Quindi, se osserviamo da vicino il codice, scopriremo che ci sono 5 affermazioni in totale e le due di queste affermazioni sono effettivamente condizioni. Quindi una copertura del percorso inizierà dal primo percorso e controllerà se la condizione è vera. In caso contrario, passerà alla parte else ed eseguirà la dichiarazione 4 e 5. Quindi in tutte le dichiarazioni coperte sono 1,3,4,5. Mentre nella condizione di copertura la parte if e la parte else sono verificate, non solo la quinta affermazione, vale a dire solo le dichiarazioni 1 e 3 sono verificate. Ma nota anche che se c'erano solo le condizioni allora qui in questo caso copertura del percorso = copertura dell'affermazione.

Come già detto, neanche

1. La copertura del percorso implica la copertura delle condizioni NOR
2. La copertura delle condizioni implica la copertura del percorso

Ci sono esempi molto semplici che dimostrano che:

(1): Path Coverage non implica Copertura delle condizioni:

if (A and B) then
    some elementary statement(s)
end if

La copertura del percorso è fornita da:

• A = false
• A = true and B = true

Ma : per la copertura delle condizioni è necessario anche A = true and B = false .

(2): la copertura delle condizioni non implica la copertura del percorso:

if (A)
    some elementary statement(s)
end if
if (B)
    some (other) elementary statement(s)
end

La copertura delle condizioni è fornita da:

• A = false and B = false
• A = true and B = true

Ma : per copertura del percorso richiediamo A = false and B = true e A = true and B = false .