The focus in mutation testing is on the elimination of first-order mutants. It is widely believed that there is a coupling effect between first-order and higher-order mutants such that a test set that kills the former would be expected to kill the latter too; it follows that, if the belief is correct, there is no need whatsoever to bother with higher-order mutants. It turns out, in practice, that most higher-order mutants do get killed by such a test set, though a few somehow manage to survive. This is the first of two papers dealing with the coupling effect from a theoretical standpoint. The overall results indicate that the hypothesis of a coupling effect is largely valid, provided the program is not too large; only a tiny proportion of higher-order mutants is expected to survive a test set that kills all first-order mutants. The basis of the approach is that programs can be modelled as compositions of finite functions, the domain of which is assumed to be large. The problem is a complex one, so the present paper only considers the case where there is just one test data; the case where there are more than one test data is left to a second paper. The aim is not only to show that the coupling effect actually exists, but also to gain some understanding of the various factors underlying it.

Fault coupling is the phenomenon whereby a test set is able to detect faults when they occur in isolation, but fails to do so when they occur in combination. It is widely regarded as a nuisance in fault-based approaches to software testing, which focus on the detection of single faults and normally neglect multiple faults. This paper presents a theoretical study of fault coupling, based on a simple model of fault-based testing. This provides for the presence of two faults that interact with each other and thus includes the possibility of fault coupling between them. The model is analysed mathematically, the conclusion reached being that fault coupling only occurs infrequently. This result provides support for current approaches to fault-based testing, but it is not quite enough to conclude that they are thereby validated. In effect, the paper generalizes the results of a previous paper that dealt with the restricted case where the functions underlying programs are bijective as well as finite. The restriction that functions be bijective is lifted here, but they are still required to be finite. Though the same theoretical framework is used in both cases, and more or less the same results are obtained, the techniques employed to arrive at the results in the general case are quite different.

Fault-based testing attempts to show that particular faults cannot exist in software by using test sets that differentiate between the original program (hypothesized to be correct) and faulty alternate programs. The success of this approach depends on a number of assumptions, notably that programmers are competent insofar as they only commit relatively trivial faults, and that faults only couple infrequently. Fault coupling occurs when test sets are able to differentiate between the original program and faulty alternate programs when faults occur in isolation, but not when they occur in combination; it is a complicating factor in fault-based testing. Fault coupling is studied here within the context of finite bijective functions. A complete mathematical solution of the problem is possible in this simplified case; the results indicate that fault coupling does indeed occur infrequently, and are thus in agreement with the empirical results obtained by others in the field. One surprising result is that certain kinds of test set are able to avoid fault coupling altogether.