View source for Elementary comparison testing

'''Elementary comparison testing''' ('''ECT''') is a [[White-box testing|white-box]], [[Control flow|control-flow]], [[Test design|test-design]] methodology used in [[Software development|software development]].<ref name="leecopeland">Lee Copeland (2004). ''A Practitioners Guide to Software Test Design'', chapter 10. Artech House Publishers, Norwood. {{ISBN|0140289712}}.</ref><ref>{{Cite web |title=All about the elementary comparison test {{!}} Testlearning | url=https://www.testlearning.net/en/posts/elementary-comparison-test |access-date=2022-09-02 |website=www.testlearning.net |language=en}}</ref> The purpose of ECT is to enable detailed testing of complex software. Software code or [[Pseudocode|pseudocode]] is tested to assess the proper handling of all decision outcomes. As with [[Code coverage|multiple-condition coverage]]<ref>Glenford J. Myers (2004). ''The Art of Software Testing, Second Edition'', p. 40., John Wiley & Sons, New Jersey. {{ISBN|0-471-46912-2}}.</ref> and [[Basis path testing|basis path testing]],<ref name="leecopeland" /> coverage of all independent and isolated conditions is accomplished through modified condition/decision coverage (MC/DC).<ref>Tim Kroom (2006). ''TMap Next, for result driven testing'', p. 668. UTN Publishers, Rotterdam. {{ASIN|B01K3PXI5U}}.</ref> Isolated conditions are aggregated into connected situations creating formal [[Test case|test case]]s. The independence of a condition is shown by changing the condition value in isolation. Each relevant condition value is covered by [[Test case|test case]]s.
==Test case==
A [[Test case|test case]] consists of a logical path through one or many decisions from start to end of a process. Contradictory situations are deduced from the test case matrix and excluded. The MC/DC approach isolates every condition, neglecting all possible subpath combinations and path coverage.<ref name="leecopeland" />
<math display="block">T=n+1</math>
where
* ''T'' is the number of test cases per decision and
* ''n'' the number of conditions.

The decision <math>d_i</math> consists of a combination of elementary conditions

<math display="block">\begin{align}
\Sigma &= \{0, 1\}\\
C&=\{c_0, c_1, c_2, c_3,..., c_n\}
\end{align}</math>
<math display="block">\epsilon : C \to \Sigma \times C</math>
<math display="block">D \subseteq C^* \,;\; d_i \in D</math>

The transition function <math>\alpha</math> is defined as
<math display="block">\alpha : D \times \Sigma^* \to \Sigma \times D</math>

Given the transition <math>\vdash</math>
<math display="block">\vdash \subseteq (\Sigma \times D \times \Sigma^*) \times (\Sigma \times D \times \Sigma^*)</math>

<math display="block">S_j=(b_j, d_m, v_j) \vdash (b_{j+1}, d_n, v_{j+1})</math>
<math display="block">E_j=(a_j, c_j) \vdash (a_{j+1}, c_k)</math>
<math display="block">(b_{j+1}, d_n) = \alpha(d_m, v_j); (b_{j+1}, c_k) = \epsilon(c_j); a_j \in \Sigma,</math>
the isolated test path <math>P_m</math> consists of
<math display="block">
\begin{align}
P_m &= (b_0, d_0, v_0) \vdash ... \vdash (b_i, d_i, v_i) \vdash^*(b_n, d_n, v_n) \\
    &= (b_0, c_0) \vdash ... \vdash (b_m, c_m) \vdash^* (b_n, c_n)
\end{align}
</math>
<math display="block">b_i \in \Sigma; c_m \in d_i; v \in C^*; d_0=S; d_n=E.</math>

==Test case graph==
A test case graph illustrates all the necessary independent paths (test cases) to cover all isolated conditions. Conditions are represented by nodes, and condition values (situations) by edges. An edge addresses all program situations. Each situation is connected to one preceding and successive condition. Test cases might overlap due to isolated conditions.

==Inductive proof of a number of condition paths==
The elementary comparison testing method can be used to determine the number of condition paths by inductive proof.

[[File:ECT Example Inductive Proof Plain.svg|thumb|right|upright=2|Figure 2: ECT Inductive Proof Anchor]]

There are <math>r = 2^n</math> possible condition value combinations
<math display="block">\forall{i} \in \{1,...,n\},\ c_i\mapsto\{0,\ 1\}.</math>

When each condition <math>c_i</math> is isolated, the number of required test cases <math>T</math> per decision is:
<math display="block">T = \log_2(r)+1 = n + 1.</math>
{{clear|right}}

[[File:ECT Example Inductive Proof Plain 4.svg|thumb|right|upright=2|Figure 3: ECT Inductive Proof End]]

<math>\forall{i}\in\{1,...,n\}</math> there are <math>0<e<i+1</math> edges from parent nodes <math>c_i</math> and <math>s = 2</math> edges to child nodes from <math>c_i</math>.

Each individual condition <math>c_i</math> connects to at least one path
<math display="block">\forall{i}\in\{1,...,n-1\} , \ c_i\mapsto\{0,\ 1\}</math>
from the maximal possible <math>n</math> connecting to <math>c_n</math> isolating <math>c_n</math>.

All predecessor conditions <math>c_i;\ i<n</math> and respective paths are isolated. Therefore, when one node (condition) is added, the total number of paths, and required test cases, from start to finish increases by:
<math display="block">T = n-1+2 = n+1. </math>
[[Q.E.D.]]

{{clear|right}}

==Test-case design steps==
# Identify decisions
# Determine test situations per decision point (Modified Condition / Decision Coverage)
# Create logical test-case matrix
# Create physical test-case matrix

==Example==
[[File:ECT Example Control Flows.svg|thumb|right|upright=1|Figure 4: ECT Example Control-Flow Graph]]
[[File:ECT Example Decision D2 Conditions.svg|thumb|right|upright=1|Figure 5: ECT Example D2 Conditions]]

This example shows ETC applied to a holiday booking system. The discount system offers reduced-price vacations. The offered discounts are <math>-20\%</math> for members or for expensive vacations, <math>-10\%</math> for moderate vacations with workday departures, and <math>0\%</math> otherwise. The example shows the creation of logical and physical test cases for all isolated conditions.

'''Pseudocode'''

 '''if''' days > 15 '''or''' price > 1000 '''or''' member '''then'''
     '''return''' −0.2
 '''else if''' (days > 8 '''and''' days ≤ 15 '''or''' price ≥ 500 '''and''' price ≤ 1000) '''and''' workday '''then'''
     '''return''' −0.1
 '''else'''
     '''return''' 0.0

'''Factors'''

* Number of days: <math><8;\ 8-15;\ >15</math>
* Price (euros): <math><500;\ 500-1000;\ >1000</math>
* Membership card: none; silver; gold; platinum
* Departure date: workday; weekend; holiday

<math>T = 3 \times 3 \times 4 \times 3 = 108</math> possible combinations (test cases).

{{clear|right}}

Example in [[Python (programming language)|Python]]:
<source lang="python">
if days > 15 or price > 1000 or member:
    return -0.2
elif (days > 8 and days <= 15 or price >= 500 and price <= 1000) and workday:
    return -0.1
else:
    return 0.0
</source>

===Step 1: Decisions===
{| class="wikitable floatright" style="text-align: center"
|+Table 1: Example D1 MC/DC
|-
! colspan="2" | 
! colspan="6" | Outcome
|-
|-
! colspan="2" | Decision D1
! colspan="3" | 1 
! colspan="3" | 0
|-
! colspan="2"| Conditions 
! c1 !! c2 !! c3 !! c1 !! c2 !! c3
|-
| c1 || <math>\text{days}>15</math>|| '''1''' || 0 || 0 || '''0''' || 0 || 0
|-
| c2 || <math>\text{price}>1000</math>|| 0 || '''1''' || 0 || {{strikethrough|0}} || {{strikethrough|'''0'''}} || {{strikethrough|0}} 
|-
| c3 || <math>\text{member}</math>|| 0 || 0 || '''1''' || {{strikethrough|0}} || {{strikethrough|0}} || {{strikethrough|'''0'''}}
|}

<math display="block">\begin{align}
d_1 &= \text{days} > 15\ \text{or}\ \text{price} > 1000\ \text{Eur}\ \text{or}\ \text{member} \\
c_1 &= \text{days} > 15 \\
c_2 &= \text{price} > 1000 \\
c_3 &= \text{member} \\
\end{align}</math>
<math display="block">\begin{align}
d_2 &= (8 < \text{days} < 15\ \text{or}\ 500 < \text{price} < 1000\ \text{Eur})\ \text{and}\ \text{workday} \\
c_4 &= 8 < \text{days} < 15 \\
c_5 &= 500 < \text{price} < 1000\ \text{Eur}\\
c_6 &= \text{workday} \\
\end{align}</math>
{{clear|right}}

===Step 2: MC/DC Matrix===
{| class="wikitable floatright" style="text-align: center"
|+Table 2: Example D2 MC/DC
|-
! colspan="2" | 
! colspan="6" | Outcome
|-
|-
! colspan="2" | Decision D2
! colspan="3" | 1 
! colspan="3" | 0
|-
! colspan="2"| Conditions 
! c4 !! c5 !! c6 !! c4 !! c5 !! c6
|-
| c4 || <math>8<\text{days}<15</math>|| '''1''' || 0 || 1 || '''0''' || 0 || 1
|-
| c5 || <math>500 < \text{price} < 1000</math>|| 0 || '''1''' || 1 || {{strikethrough|0}} || {{strikethrough|'''0'''}} || {{strikethrough|1}} 
|-
| c6 || <math>\text{workday}</math>|| {{strikethrough|1}} || {{strikethrough|0}} || {{strikethrough|'''1'''}} || 1 || 0 || '''0'''
|}

The highlighted diagonals in the MC/DC Matrix are describing the isolated conditions:
<math display="block">(c_i,c_i) \mapsto \{1,0\}</math>
all duplicate situations are regarded as proven and removed.
{{clear}}

===Step 3: Logical test-Case matrix===
{| class="wikitable floatright" style="text-align: center"
|+Table 3: Example Logical Test Case Matrix
|-
! Situation <math>S_{j}</math> !! <math>T_1</math> !! <math>T_2</math> !! <math>T_3</math> !! <math>T_4</math> !! <math>T_5</math> !! <math>T_6</math> !! <math>T_7</math>
|-
| <math>\alpha(d_1, \mathbf{1}00) \mapsto (1, E)</math>   || x || || || || || ||
|-
| <math>\alpha(d_1, \mathbf{0}00) \mapsto (0, d_2)</math> || || x || || || x || x || x
|-
| <math>\alpha(d_1, 0\mathbf{1}0) \mapsto (1, E)</math>   || || || x || || || ||
|-
| <math>\alpha(d_1, 00\mathbf{1}) \mapsto (1, E)</math>   || || || || x || || ||
|-
| <math>\alpha(d_2, \mathbf{1}01) \mapsto (1, E)</math>    || || x || || || || ||
|-
| <math>\alpha(d_2, \mathbf{0}01) \mapsto (1, E)</math>   || || || || || || x ||
|-
| <math>\alpha(d_2, 0\mathbf{1}1) \mapsto (1, E)</math>    || || || || || x || ||
|-
| <math>\alpha(d_2, 11\mathbf{0}) \mapsto (0, E)</math>   || || || || || || || x
|}

Test cases are formed by tracing decision paths. For every decision <math>d_i;\ 0 < i < n+1</math> a succeeding and preceding subpath is searched until every connected path has a start <math>S</math> and an end <math>E</math>:
<math display="block">\begin{align}
T_1&=(d_1, 100) \vdash (1, E) \\
T_2&=(d_1, 000) \vdash (0, d_2, 100) \vdash (1, E) \\
T_3&=(d_1, 010) \vdash (1, E) \\
\vdots \\
T_{n+1}
\end{align}</math>
{{clear}}

===Step 4: Physical test-case matrix===
{| class="wikitable floatright" style="text-align: center"
|+Table 4: Example Physical Test Cases
|-
! Factor\Test Case !! <math>T_1</math> !! <math>T_2</math> !! <math>T_3</math> !! <math>T_4</math> !! <math>T_5</math> !! <math>T_6</math> !! <math>T_7</math>
|-
| days      || 16 ||  14   ||      ||        || 8 || 8   || 8
|-
| price     ||    ||       || 1100 ||        ||   || 600 || 
|-
| departure ||    ||       ||      ||        ||   ||     || sa
|-
| member    ||    ||       ||      || silver ||   ||     || 
|-
!colspan=8 style="text-align:left"|  Result
|-
| 0         ||   ||        ||      ||        ||   ||    || 0
|-
| -10       ||   || 1      ||      ||        || 1 || 1  || 
|-
| -20       || 1 ||        || 1    || 1      ||   ||    || 
|}

Physical test cases are created from logical test cases by filling in actual value representations and their respective results.
{{clear}}

===Test-case graph===
[[File:ECT Example Test Case Graph c.svg|thumb|right|upright=1.5|Figure 6: ECT Example Test Case Graph]]
In the example test case graph, all test cases and their isolated conditions are marked by colors, and the remaining paths are implicitly passed.

==See also==
* {{slink|Code coverage#Multiple condition coverage}}
* [[Control-flow graph]]
* [[Decision-to-decision path]]

==References==
<references />

[[Category:Software testing]]

{{Sourceattribution|Elementary comparison testing}}