implementations. Mutation testing overview Mutation testing is based on two hypotheses. The first is the competent programmer hypothesis. This hypothesis states that competent programmers write programs that are close to being correct. "Close" is intended to be based on behavior, not syntax. The second hypothesis is called the coupling effect. The coupling effect asserts that simple faults can cascade or couple to form other emergent faults. Subtle and important faults are also revealed by higher-order mutants, which further support the coupling effect. Higher-order mutants are enabled by creating mutants with more than one mutation. Mutation testing is done by selecting a set of mutation operators and then applying them to the source program one at a time for each applicable piece of the source code. The result of applying one mutation operator to the program is called a mutant. If the test suite is able to detect the change (i.e. one of the tests fails), then the mutant is said to be killed. For example, consider the following C++ code fragment: if (a && b) { c = 1; } else { c = 0; } The condition mutation operator would replace && with || and produce the following mutant: if (a || b) { c = 1; } else { c = 0; } Now, for the test to kill this mutant, the following three conditions should be met: A test must reach the mutated statement. Test input data should infect the program state by causing different program states for the mutant and the original program. For example, a test with a = 1 and b = 0 would do this. The incorrect program state (the value of 'c') must propagate to the program's output and be checked by the test. These conditions are collectively called the RIP model. Weak mutation testing (or weak mutation coverage) requires that only the first and second conditions are satisfied. Strong mutation testing requires that all three conditions are satisfied. Strong mutation is more powerful, since it ensures that the test suite can really catch the problems. Weak mutation is closely related to code coverage methods. It requires much less computing power to ensure that the test suite satisfies weak mutation testing than strong mutation testing. However, there are cases where it is not possible to find a test case that could kill this mutant. The resulting program is behaviorally equivalent to the