Unit Testing

Getting jUnit

jUnit Basics

public class Philadelphia {
	public static boolean isItSunny() {
		return true;
	}
}

import static org.junit.Assert.*;

import org.junit.Test;


public class PhiladelphiaTest {

	@Test
	public void testIsItSunny() {
		assertTrue(Philadelphia.isItSunny());
	}

}

Running jUnit

Command Line

• The class being tested needs to be compiled - if it hasn't yet compile as usual

javac Philadelphia.java

• The test class also needs to be compiled (including the jUnit jar file in the path)

javac -cp "junit-4.9b2.jar;." PhiladelphiaTest.java

javac -cp "junit-4.9b2.jar:." PhiladelphiaTest.java

• Finally, execute the test by invoking the "org.junit.runner.JUnitCore" class in the jUnit jar and providing it a list of classes which contain tests to be run (in our case just "PhiladelphiaTest").

java -cp "junit-4.9b2.jar;." org.junit.runner.JUnitCore PhiladelphiaTest

java -cp "junit-4.9b2.jar:." org.junit.runner.JunitCore PhiladelphiaTest

egrim@mpc-tablet-1 ~/workspace/jScratch/src
$ java -cp "junit-4.9b2.jar;." org.junit.runner.JUnitCore PhiladelphiaTest
JUnit version 4.9b2
.
Time: 0.009

OK (1 test)

Eclipse

• Select "New JUnit 4 test"
• Name: PhiladelphiaTest
• Class under test: Philadelphia

Test Fixtures

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class ArrayListTest {

	List<Integer> testArray;

	/**
	 * This method is invoked before each test is run to set up the test array
	 * with a known set of values.
	 */
	@Before
	// Informs JUnit that this method should be run before each test
	public void setUp() {
		testArray = new ArrayList<Integer>(Arrays.asList(3, 1, 4, 1, 5));
	}

	/**
	 * This method is invoked after each test is run to perform tear down
	 * activities (not needed in this test fixture).
	 */
	@After
	// Informs JUnit that this method should be run after each test
	public void tearDown() {
		// No tear down needed for this test
	}

	/**
	 * Adds a value to the array and verifies the add was successful.
	 */
	@Test
	public void testAdd() {
		testArray.add(9);

		List<Integer> expected = 
			new ArrayList<Integer>(Arrays.asList(3, 1, 4, 1, 5, 9));

		assertEquals(testArray, expected);
	}

	/**
	 * Removes a value from the array and verifies the remove was successful.
	 */
	@Test
	public void testRemoveObject() {
		testArray.remove(new Integer(5));

		List<Integer> expected = 
			new ArrayList<Integer>(Arrays.asList(3, 1, 4, 1));

		assertEquals(testArray, expected);
	}

	/**
	 * Tests the indexOf method and verifies the expected return value.
	 */
	@Test
	public void testIndexOf() {
		assertEquals(testArray.indexOf(4), 2);
	}

}

egrim@mpc-tablet-1 ~/workspace/jScratch/src
$ java -cp "junit-4.9b2.jar;." org.junit.runner.JUnitCore ArrayListTest
JUnit version 4.9b2
...
Time: 0.007

OK (3 tests)

Coverage

• Statement Coverage:  This coverage metric measure the percentage of statements being exercised by tests.
  
• Branch Coverage:  Also known as condition coverage, this coverage metric measures the percentage of true and false evaluations of branches exercised by tests.  For example, full branch coverage is achieved when each conditional expression is evaluated to both true and false.
  
• Path Coverage:  This coverage metric measures the percentage of program paths exercised by the tests.  For example, if the code has three branches - full path coverage would be achieved by testing each possible combination of branch decisions (e.g.:  true-true-true, true-true-false, true-false-true, etc. - leading to eight candidate paths).

public class CoverageExample {
	/**
	 * A simple function that should return exactly the provided integer input.
	 * 
	 * The function below is expected to take in a value and return exactly the
	 * same value. The manner in which the return value is calculated is
	 * affected by three boolean values, but regardless of the boolean values
	 * input, the function should already return the originally provided integer
	 * value.
	 * 
	 * The implementation below has a bug, but the bug only manifests itself
	 * under a specific set of inputs. The intent here is to demonstrate that
	 * not all test coverage types are sufficient to find all bugs.
	 * 
	 * @param x
	 *            the value to be returned.
	 * @param cond1
	 *            the boolean that causes x to be incremented when true.
	 * @param cond2
	 *            the boolean that causes x to be decremented when true.
	 * @param cond3
	 *            the boolean that causes x to be multiplied by 1 when true.
	 * @return the original value of x.
	 */
	public static int identity(int x, boolean cond1, boolean cond2, boolean cond3) {
		if (cond1) {      // Statement 1 (S1), Branchpoint 1 (B1)
			x++;      // Statement 2 (S2)
		}

		if (cond2) {      // Statement 3 (S3), Branchpoint 2 (B2)
			x--;      // Statement 4 (S4)
		}

		if (cond3) {      // Statement 5 (S5), Branchpoint 3 (B3)
			x *= 1;   // Statement 6 (S6)
		}

		return x;         // Statement 7 (S7)
	}
}

    @Test
    public void testIdentityAllTrue() {
        assertEquals(0, CoverageExample.identity(0, true, true, true));
    }

    @Test
    public void testAllFalse() {
        assertEquals(0, CoverageExample.identity(0, false, false, false));
    }

    @Test 
    public void testTrueTrueFalse() {
        assertEquals(0, CoverageExample.identity(0, true, true, false));
    }
    
    @Test 
    public void testTrueFalseTrue() {
        assertEquals(0, CoverageExample.identity(0, true, false, true));
    }
    
    @Test 
    public void testTrueFalseFalse() {
        assertEquals(0, CoverageExample.identity(0, true, false, false));
    }
    
    @Test 
    public void testFalseTrueTrue() {
        assertEquals(0, CoverageExample.identity(0, false, true, true));
    }
    
    @Test 
    public void testFalseTrueFalse() {
        assertEquals(0, CoverageExample.identity(0, false, true, false));
    }

    @Test 
    public void testFalseFalseTrue() {
        assertEquals(0, CoverageExample.identity(0, false, false, true));
    }

import static org.junit.Assert.*;

import org.junit.Test;


public class IdentityTest {

    // Statement Coverage
    @Test
    public void testAllTrue() {
        assertEquals(0, CoverageExample.identity(0, true, true, true));
    }
    
    // Branch Coverage, all of the above plus the following
    @Test
    public void testAllFalse() {
        assertEquals(0, CoverageExample.identity(0, false, false, false));
    }

    // Path Coverage, all of the above plus the following
    @Test 
    public void testTrueTrueFalse() {
        assertEquals(0, CoverageExample.identity(0, true, true, false));
    }
    
    @Test 
    public void testTrueFalseTrue() {
        assertEquals(0, CoverageExample.identity(0, true, false, true));
    }
    
    @Test 
    public void testTrueFalseFalse() {
        assertEquals(0, CoverageExample.identity(0, true, false, false));
    }
    
    @Test 
    public void testFalseTrueTrue() {
        assertEquals(0, CoverageExample.identity(0, false, true, true));
    }
    
    @Test 
    public void testFalseTrueFalse() {
        assertEquals(0, CoverageExample.identity(0, false, true, false));
    }

    @Test 
    public void testFalseFalseTrue() {
        assertEquals(0, CoverageExample.identity(0, false, false, true));
    }

}

public class TimeParser {
	private static final int MINS_PER_HR = 60;
	private static final int SECS_PER_MIN = 60;
	
	private static final int MIN_HRS = 0;
	private static final int MAX_HRS = 23;
	private static final int MIN_MINS = 0;
	private static final int MAX_MINS = 59;
	private static final int MIN_SECS = 0;
	private static final int MAX_SECS = 59; // ignore leap seconds
	
	public static int parseTimeToSeconds(String time) throws NumberFormatException {
		// Normalize the input (trim whitespace and make lower case)
		time = time.trim().toLowerCase();
		
		int firstColon = time.indexOf(':');
		if (firstColon == -1) {
			throw new NumberFormatException("Unrecognized time format");
		}

		int secondColon = time.indexOf(':', firstColon+1);
		if (secondColon == -1) {
			throw new NumberFormatException("Unrecognized time format");
		}
		
		// Interpret everything up to the first colon as the hour
		int hours = Integer.valueOf(time.substring(0, firstColon));
		// Interpret everything between the two colons as the minute
		int minutes = Integer.valueOf(time.substring(firstColon+1, secondColon));
		// Interpret the two characters after the second colon as the seconds
		int seconds = Integer.valueOf(time.substring(secondColon+1, secondColon+3));
		
		// Adjust hours if 'pm' specified
		if (time.contains("pm")) {
			hours += 12;
		}
		
		// Range check the values
		if ((hours < MIN_HRS || hours > MAX_HRS) ||
			(minutes < MIN_MINS || minutes > MAX_MINS) ||
			(seconds < MIN_SECS || seconds > MAX_SECS)) {
				throw new IllegalArgumentException("Unacceptable time specified");
		}

		// Calculate number of seconds since midnight
		return (((hours * MINS_PER_HR) + minutes) * SECS_PER_MIN) + seconds;
	}
}

Invariants

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Iterator;

/**
 * A HeapArray holds element on a priority heap, which orders the elements
 * according to their natural order.
 * <p>
 * The heap data structure maintains the invariant that in its underlying tree
 * structure the parent is less than all of its children. This implementation
 * maps the tree structure into an array which maintains the heap invariant such
 * that array[n] <= array[2*n] and array[n] <= array[2*n+1] for all elements in
 * the array.
 * 
 * @param <E>
 *            the type of the objects stored in the array (must implement
 *            Comparable)
 */
public class HeapArray<E extends Comparable<E>> implements Iterable<E> {
    private static final int DEFAULT_CAPACITY = 11;

    private static final int DEFAULT_CAPACITY_RATIO = 2;

    private int size;

    private E[] elements;

    /**
     * Constructs a heap array with an initial capacity of 11.
     */
    public HeapArray() {
        this(DEFAULT_CAPACITY);
    }

    /**
     * Constructs a heap array with the specified capacity.
     * 
     * @param initialCapacity
     *            the desired initial capacity.
     */
    public HeapArray(int initialCapacity) {
        if (initialCapacity < 1) {
            throw new IllegalArgumentException();
        }

        elements = newElementArray(initialCapacity);
    }

    /**
     * Remove all elements from the heap array
     */
    public void clear() {
        Arrays.fill(elements, null);
        size = 0;
    }

    /**
     * Adds the specified object to the heap array.
     * 
     * @param o
     *            - the object to be added
     */
    public void add(E o) {
        if (null == o) {
            throw new NullPointerException();
        }
        int i = size;
        if (i >= elements.length)
            growToSize(i + 1);
        size = i + 1;
        if (i == 0)
            elements[0] = o;
        else
            siftUp(i, o);
    }

    /**
     * Remove the smallest item from the heap array.
     * 
     * @return - the smallest item in the heap array.
     */
    public E pop() {
        if (isEmpty()) {
            return null;
        }
        E result = elements[0];
        removeAt(0);
        return result;
    }

    /**
     * Get the element stored at the specified index in the heap array.
     * 
     * @param index
     *            the index of the element.
     * @return the element stored at the specified index.
     */
    public E get(int index) {
        return elements[index];
    }

    /**
     * Peek at the smallest item in the heap array (but do not remove it).
     * 
     * @return the smallest item in the heap array.
     */
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return elements[0];
    }

    /**
     * Remove the specified object from the heap array.
     * 
     * @param o
     *            the object to be removed.
     * @return whether or not the request object was found and removed.
     */
    public boolean remove(Object o) {
        if (o == null) {
            return false;
        }
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(o)) {
                removeAt(i);
                return true;
            }
        }
        return false;
    }

    /**
     * Check whether or not the heap array contains the specified object.
     * 
     * @param object
     *            the object to be checked.
     * @return whether or not the specified object is in the heap array.
     */
    public boolean contains(Object object) {
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(object)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Check if the heap array is empty.
     * 
     * @return whether or not the heap array is empty.
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * Return the size of the heap array (how many items are in it).
     * 
     * @return the size of the heap array.
     */
    public int size() {
        return size;
    }

    /**
     * Returns a new array containing all the elements contained in the heap
     * array.
     * 
     * @return the new array containing all the elements contained in the heap
     *         array
     */
    public Comparable<E>[] toArray() {
        return Arrays.copyOf(elements, elements.length);
    }

    /**
     * Returns an array containing all the elements contained in the heap array.
     * If the specified array is large enough to hold the elements, the
     * specified array is used, otherwise an array of the same type is created.
     * If the specified array is used and is larger than the heap array, the
     * array element following the heap array contents is set to null.
     * 
     * @param <T>
     *            the array element type used for the return array.
     * @param destinationArray
     *            the array used as specified above.
     * @return the new array containing the elements contained in the heap
     *         array.
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] destinationArray) {
        if (size > destinationArray.length) {
            Class<?> ct = destinationArray.getClass().getComponentType();
            destinationArray = (T[]) Array.newInstance(ct, size);
        }
        System.arraycopy(elements, 0, destinationArray, 0, size);
        if (size < destinationArray.length) {
            destinationArray[size] = null;
        }
        return destinationArray;
    }

    @SuppressWarnings("unchecked")
    private E[] newElementArray(int capacity) {
        return (E[]) new Comparable[capacity];
    }

    private void removeAt(int index) {
        size--;
        if (size == index)
            elements[index] = null;
        else {
            E moved = elements[size];
            elements[size] = null;
            siftDown(index, moved);
            if (elements[index] == moved) {
                siftUp(index, moved);
            }
        }
    }

    /**
     * Inserts target at position childIndex, maintaining heap invariant by
     * promoting target up the tree until it is greater than or equal to its
     * parent, or is the root.
     * 
     * @param childIndex
     *            the index used for the original placement of target.
     * @param target
     *            the item to be placed and sifted.
     */
    private void siftUp(int childIndex, E target) {
        while (childIndex > 0) {
            int parentIndex = (childIndex - 1) / 2;
            E parent = elements[parentIndex];
            if (target.compareTo(parent) >= 0)
                break;
            elements[childIndex] = parent;
            childIndex = parentIndex;
        }
        elements[childIndex] = target;
    }

    /**
     * Inserts target at position index, maintaining the heap invariant by
     * demoting target down the tree repeatedly until it is less than or equal
     * to its children or is a leaf.
     * 
     * @param index the index where target should initially be placed.
     * @param target the item to be placed and sifted down.
     */
    private void siftDown(int index, E target) {
        int half = size / 2;
        while (index < half) {
            int childIndex = index * 2 + 1;
            E child = elements[childIndex];
            int rightIndex = childIndex + 1;
            if (rightIndex < size 
                    && child.compareTo(elements[rightIndex]) > 0) {
                childIndex = rightIndex;
                child = elements[childIndex];
            }
            if (target.compareTo(child) <= 0)
                break;
            elements[index] = child;
            index = childIndex;
        }
        elements[index] = target;
    }

    private void growToSize(int size) {
        if (size > elements.length) {
            E[] newElements = newElementArray(size * DEFAULT_CAPACITY_RATIO);
            System.arraycopy(elements, 0, newElements, 0, elements.length);
            elements = newElements;
        }
    }

    @Override
    public Iterator<E> iterator() {
        return Arrays.asList(elements).iterator();
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        }

        StringBuilder buffer = new StringBuilder(size * 16);
        buffer.append('[');
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            E next = it.next();
            if (next != this) {
                buffer.append(next);
            } else {
                buffer.append("(this HeapArray)");
            }
            if (it.hasNext()) {
                buffer.append(", ");
            }
        }
        buffer.append(']');
        return buffer.toString();
    }
}

import static org.junit.Assert.*;

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;

import org.junit.Before;
import org.junit.Test;


public class MinHeapArrayInvariant1Test {
    private static final long SEED = 42;
    private static final long VALUES_TO_TEST = 1000;
    
    private Random random;
    private HeapArray<Integer> heap;
    
    @Before
    public void setUp() {
        random = new Random(SEED);
        heap = new HeapArray<Integer>();
    }
    
    @Test
    public void testWithRandomAdds() {
        for (int i=0; i < VALUES_TO_TEST; i++) {
            int addMe = random.nextInt();
            heap.add(addMe);
            assertTrue(invariantHolds());
        }
    }
    
    @Test
    public void testWithRandomRemoves() {
        fillWithRandomValues(VALUES_TO_TEST);
        while (heap.size() > 0) {
            int indexToRemove = random.nextInt(heap.size());
            Integer removeMe = heap.get(indexToRemove);
            heap.remove(removeMe);
            assertTrue(invariantHolds());
        }
    }
    
    @Test
    public void testPop() {
        fillWithRandomValues(VALUES_TO_TEST);
        while (heap.size() > 0) {
            heap.pop();
            assertTrue(invariantHolds());
        }
    }
    
    @Test
    public void testClear() {
        fillWithRandomValues(VALUES_TO_TEST);
        heap.clear();
        assertTrue(invariantHolds());
    }

    private boolean invariantHolds() {
        Integer top = heap.peek();
        if (top == null) {
            return true;
        }
        
        Integer[] contents = new Integer[heap.size()];
        Integer min = Collections.min(Arrays.asList(heap.toArray(contents)));
        if (min > top) {
            System.out.println("Whoops!");
        }
        return min <= top;
    }

    private void fillWithRandomValues(long numValues) {
        for (int i = 0; i < numValues; i++){
            heap.add(random.nextInt());
        }
    }
}

• jUnit.org
• jUnit Documentation
• Path and Branch Coverage