One Test at a Time - Automatic Generation of Combinatorial Test Data - page 33

Table 3.5 Test suite
generated by AETG

p 1 p 2 p 3 p 4

1 1 1 1

1 2 2 2

2 2 1 1

1 1 2 2

2 2 2 2

1 1 1 2

1 1 2 1

{ /////////////////////////// ( 1 , 1 , - , - ) , /////////////////////////// ( 1 , 2 , - , - ) , ///////////////////////// ( 2 , 1 , - , - ) ///////////////////////// (2,2,-,-),

/////////////////////////// ( 1 , - , 1 , - ) , /////////////////////////// ( 1 , - , 2 , - ) , ///////////////////////// ( 2 , - , 1 , - ) , /////////////////////////// (2,-,2,-),

/////////////////////////// ( 1 , - , - , 1 ) , /////////////////////////// ( 1 , - , - , 2 ) , ///////////////////////// ( 2 , - , - , 1 ) , /////////////////////////// (2,-,-,2),

/////////////////////////// ( - , 1 , 1 , - ) , /////////////////////////// ( - , 1 , 2 , - ) , ///////////////////////// ( - , 2 , 1 , - ) , /////////////////////////// (-,2,2,-),

/////////////////////////// ( - , 1 , - , 1 ) , /////////////////////////// ( - , 1 , - , 2 ) , ///////////////////////// ( - , 2 , - , 1 ) , /////////////////////////// (-,2,-,2),

/////////////////////////// ( - , - , 1 , 1 ) , ( - , - , 1 , 2 ) , ( - , - , 2 , 1 ) , ///////////////////////// (-,-,2,2) } .

Iteration #6 For the sixth iteration, p 3 and value 1 are selected (valid). And for
parameter order p 1 , p 2 , p 4 , values “1(valid), 1(valid), 2(valid)” is selected, and can-

didate ( 1 , 1 , 1 , 2 ) is generated. Then for parameter order p 2 , p 1 , p 4 , values “2(valid),

2(valid), 2(valid)” is selected, and candidate is generated. Both candidates

covers 1 uncovered target combinations, and finally the first candidate is chosen.
Then, the set of remaining target combinations becomes:

( 2 , 2 , 1 , 2 )

{

/////////////////////////// ( 1 , 1 , - , - ) , /////////////////////////// ( 1 , 2 , - , - ) , ///////////////////////// ( 2 , 1 , - , - ) ///////////////////////// (2,2,-,-),

/////////////////////////// ( 1 , - , 1 , - ) , /////////////////////////// ( 1 , - , 2 , - ) , ///////////////////////// ( 2 , - , 1 , - ) , /////////////////////////// (2,-,2,-),

/////////////////////////// ( 1 , - , - , 1 ) , /////////////////////////// ( 1 , - , - , 2 ) , ///////////////////////// ( 2 , - , - , 1 ) , /////////////////////////// (2,-,-,2),

/////////////////////////// ( - , 1 , 1 , - ) , /////////////////////////// ( - , 1 , 2 , - ) , ///////////////////////// ( - , 2 , 1 , - ) , /////////////////////////// (-,2,2,-),

/////////////////////////// ( - , 1 , - , 1 ) , /////////////////////////// ( - , 1 , - , 2 ) , ///////////////////////// ( - , 2 , - , 1 ) , /////////////////////////// (-,2,-,2),

/////////////////////////// ( - , - , 1 , 1 ) , /////////////////////////// ( - , - , 1 , 2 ) , ( - , - , 2 , 1 ) , ///////////////////////// (-,-,2,2) } .

Similarly, for the seventh iteration, test case is generated, and all target

combinations are covered. The complete test suite is (Table 3.5 ).

( 1 , 1 , 2 , 1 )

3.3 AETG Variants

There are many other algorithms based on the one-test-at-a-time strategy. They can
be regarded as variants of AETG.
Bryce et al. [ 3 ] introduced a four-layer framework for AETG-like algorithms
which construct (mixed) CAs one row at a time. Many algorithms can be instantiated
from this framework. The layers are the following: