White Box Testing

You can see that this type of testing could quickly become unfeasible. It would be your judgement which of the tests can be omitted without compromising the quality of the testing. One approach, called partial compound condition coverage is to choose tests so that each expression is tested as either true or false. In our above case that would be:

• !done - True and False
• colour.equals("blue") - True and False
• value > 100 - True and False
• colour.equals("blue") || value > 100 - True and False
• !done && (colour.equals("blue") || value > 100) - True and False

Some of these expressions can be covered with the same test.

Questions: What would be the list of tests to achieve partial compound condition coverage of the following statements:

• (i < j || k != m)
• (name != null && (name.equals("Punch") || name.equals("Judy"))
  • Consider what would happen if we changed the above to ((name.equals("Punch") || name.equals("Judy") && name != null)
• (((u == 0) || (x>5)) && ((y<6) || (z == 0)))

Loop Coverage

Much like if statements, loops have conditions, and as such there are multiple ways to test a loop. There are six major ways of testing loops:

• Skip the loop (Zero Pass)
• One through (Single Pass)
• Twice through (Double Pass)
• N-1 Pass (may not be possible)
• N Pass (may not be possible)
• N+1 Pass (may not be possible)

Where N is the maximum number of times the loop can be executed.

Each of these cases is necessary in order to prove the value and correctness of the loop. Notice that, much like black box testing, we are testing near the limits. This is because that is where most of the errors occur.

Consider the following code. The readInts method takes in a scanner, an array of integers called the buffer, and an integer representing the length of the buffer. If we wanted to test the readInts method to ensure that the loop is executed the correct number of times, we would need the following test cases:

• Skip loop entirely: bufLen = 0
• Loop executes exactly once: buf = new int[1 or more], bufLen = 1
• Loop executes exactly twice: buf = new int[2 or more], bufLen = 2
• Loop executes n-1 times: buf = new int[n], bufLen = n-1, for some n > 0
• Loop executes n times: buf = new int[n], bufLen = n, for some n > 0
• Loop executes n+1 times: buf = new int[n], bufLen = n+1, for some n > 0
• Loop executes 2 < m < n times: buf = new int[n], bufLen = m, for some m = n / 2 (For arguments sake)

Questions:

Consider the following method:

public static void foo(int i, int n, int x, int[] v) {

    while (i < n && v[i] < x) {

        if (v[i] < 0) {

            v[i] *= -1;

        }

        System.out.println(v[i]);

        ++i;

    }

}

In order to test this method we need the ability to ensure that the loop will execute 0, 1, 2 and multiple times. Consider the code presented below.

1. Ensure that it is tested in the main function with executions 0, 1, 2, and 6 times through the loop.
2. Is there a possible way to create an n-1, n, and n+1 test for foo? If so, what would be the values of i, n, x and v?