Javaのユニットテストのサンプル

UtilTest.java

package waptest;

import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
import org.junit.*;
import java.util.Comparator;
import java.util.List;
import java.util.Arrays;

import waptest.util.*;

public class UtilTest {
    /**
     * RangeTest
     **/

    @Test
    public void testRange() {
        int im = 2147483647;
        Range r = new Range(0, im);
        assertThat(r.get(0),   is(0));
        assertThat(r.get(1),   is(im));
        assertThat(r.length(), is(im));
        r = new Range(im-1, im);
        assertThat(r.get(0), is(im-1));
        assertThat(r.get(1), is(im));
        assertThat(r.length(), is(1));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testInvalidRange() {
        Range r = new Range(1,0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testMinusRange() {
        Range r = new Range(-1,0);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRangeGetLowerLimit() {
        Range r = new Range(1, 2);
        r.get(-1);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRangeGetUpperLimit() {
        Range r = new Range(1, 2);
        r.get(2);
    }

    @Test
    public void testRangeEqual() {
        Range r0 = new Range(1, 2);
        Range r1 = new Range(1, 2);
        assert(r0.equals(r1));
    }
    
    /**
     * ArrayUtilTest
     **/

    public class EqualInteger implements Comparator<Integer> {
        @Override public int compare(Integer lhs, Integer rhs) {
            if(lhs.equals(rhs)) {
                return 0;
            } else {
                return -1;
            }
        }
    }

    @Test(expected = IllegalArgumentException.class)
    public void testArrayUtil_groupRangesEmpty() {
        Integer [] xs = {};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
    }

    @Test
    public void testArrayUtil_groupRanges1() {
        Integer [] xs = {1};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertThat(l.size(), is(1));
        assertTrue(l.get(0).equals(new Range(0,1)));
    }
    
    @Test 
    public void testArrayUtil_groupRanges11() {
        Integer [] xs = {1,1};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertThat(l.size(), is(1));
        assertTrue(l.get(0).equals(new Range(0,2)));
    }

    @Test
    public void testArrayUtil_groupRanges011() {
        Integer [] xs = {0,1,1};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertThat(l.size(), is(2));
        assertTrue(l.get(0).equals(new Range(0,1)));
        assertTrue(l.get(1).equals(new Range(1,3)));
    }

    @Test
    public void testArrayUtil_groupRanges0110() {
        Integer [] xs = {0,1,1,0};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertThat(l.size(), is(3));
        assertTrue(l.get(0).equals(new Range(0,1)));
        assertTrue(l.get(1).equals(new Range(1,3)));
        assertTrue(l.get(2).equals(new Range(3,4)));
    }

    @Test
    public void testArrayUtil_longestRange() {
        Integer [] xs = {1,2,3,4};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertTrue(l.size() == 4);
        Range r = ArrayUtil.longestRange(l);
        assertTrue(r.equals(new Range(0,1)));
    }

    @Test
    public void testArrayUtil_longestRange0110() {
        Integer [] xs = {0,1,1,0};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertTrue(l.size() == 3);
        Range r = ArrayUtil.longestRange(l);
        assertTrue(r.equals(new Range(1,3)));
    }

    @Test
    public void testArrayUtil_longestRange01100() {
        Integer [] xs = {0,1,1,0,0};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertTrue(l.size() == 3);
        Range r = ArrayUtil.longestRange(l);
        assertTrue(r.equals(new Range(1,3)));
    }

    @Test
    public void testArrayUtil_longestRange0110011() {
        Integer [] xs = {0,1,1,0,0,1,1};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertTrue(l.size() == 4);
        Range r = ArrayUtil.longestRange(l);
        assertTrue(r.equals(new Range(1,3)));
    }

    @Test
    public void testArrayUtil_longestRange01100111() {
        Integer [] xs = {0,1,1,0,0,1,1,1};
        Comparator<Integer> cmprtr = new EqualInteger();
        List<Range> l = ArrayUtil.groupRanges(xs, cmprtr);
        assertTrue(l.size() == 4);
        Range r = ArrayUtil.longestRange(l);
        assertTrue(r.equals(new Range(5,8)));
    }

    @Test
    public void testArrayUtil_longestGroup0110() {
        Integer [] xs = {0,1,1,0};
        Integer [] ys = {1,1};
        Comparator<Integer> cmprtr = new EqualInteger();
        Integer [] zs = ArrayUtil.longestGroup(xs, cmprtr);
        assertTrue(java.util.Arrays.equals(ys, zs));
    }
    @Test
    public void testArrayUtil_longestGroup1234() {
        Integer [] xs = {1,2,3,4};
        Integer [] ys = {1};
        Comparator<Integer> cmprtr = new EqualInteger();
        Integer [] zs = ArrayUtil.longestGroup(xs, cmprtr);
        assertTrue(java.util.Arrays.equals(ys, zs));
    }

    @Test
    public void testArrayUtil_longestGroup12344() {
        Integer [] xs = {1,2,3,4,4};
        Integer [] ys = {4,4};
        Comparator<Integer> cmprtr = new EqualInteger();
        Integer [] zs = ArrayUtil.longestGroup(xs, cmprtr);
        assertTrue(java.util.Arrays.equals(ys, zs));
    }

    /**
     * StringUtil
     **/

    public class EqualCharacter implements Comparator<Character> {
        @Override public int compare(Character lhs, Character rhs) {
            if(lhs.equals(rhs)) {
                return 0;
            } else {
                return -1;
            }
        }
    }

    @Test
    public void testStringUtil_longestGroupEmpty() {
        String str = "";
        Comparator<Character> cmprtr = new EqualCharacter();
        String substr = StringUtil.longestGroup(str, cmprtr);
        assertTrue(substr.equals(str));
    }

    @Test
    public void testStringUtil_longestGroupA() {
        String str = "A";
        Comparator<Character> cmprtr = new EqualCharacter();
        String substr = StringUtil.longestGroup(str, cmprtr);
        assertTrue(substr.equals(str));
    }

    @Test
    public void testStringUtil_longestGroupAB() {
        String str = "AB";
        Comparator<Character> cmprtr = new EqualCharacter();
        String substr = StringUtil.longestGroup(str, cmprtr);
        assertTrue(substr.equals("A"));
    }

    @Test
    public void testStringUtil_longestGroupABB() {
        String str = "ABB";
        Comparator<Character> cmprtr = new EqualCharacter();
        String substr = StringUtil.longestGroup(str, cmprtr);
        assertTrue(substr.equals("BB"));
    }
}