JUnit 4.4 사용후기와 팁

• 모든 소스는 Copy & Paste 만으로 실행할수 있다.

• JUnit 3.8

import static java.util.Arrays.asList;

import junit.framework.TestCase;

public class SimpleTest extends TestCase {
    private static int number;
    private static Integer staticNumber;

    public void setUp() {
        number = 10;
    }

    public void testSimple() {
        assertEquals(10, number);
        assertEquals(
            asList(new Integer[]{1,2,10}),
            asList(new Integer[]{1,2,number}));
        
        assertTrue(10 == number);    
                
        assertTrue(
            asList(new String[]{"1"}).contains("1"));
        assertTrue("123".contains("1"));
        assertNull(staticNumber);
    }

    public void testDivideByZero() {        
        try {
            assertEquals(0, number / 0);
        } catch (ArithmeticException e) {
            return;
        }
        fail();        
    }
    // 실행 방지를 위해 _ 첨가
    public void _testMultiply() {
        assertEquals(100, number);
    }

    public void tearDown() {
        number=0;
    }
}

• JUnit 4.4

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import static org.junit.matchers.JUnitMatchers.*;
import org.junit.*;

import static java.util.Arrays.asList;

public class SimpleTest {
    private int number;
    private static Integer staticNumber;

    @BeforeClass
    public static void beforeClass() {
        staticNumber = 10;
    }

    @Before
    public void setUpNumber() {
        number = 10;
    }

    @Test
    public void simple() {
        assertEquals(10, number);
        assertArrayEquals(
            new Integer[]{1,2,10},
            new Integer[]{1,2,number});
        
        assertTrue(10 == number);
        assertTrue(
            asList(new String[]{"1"}).contains("1"));
        assertTrue("123".contains("1"));
        assertNotNull(staticNumber);

        
        assertThat(number,is(10));
        assertThat(
            asList(new String[]{"1"}),hasItem("1"));

        assertThat("123",containsString("1"));
        assertThat(staticNumber,is(notNullValue()));
    }

    @Test(expected = ArithmeticException.class)
    public void divideByZero() {
        assertEquals(0, number / 0);
    }

    @Ignore("not ready yet")
    @Test
    public void multiply() {
        assertEquals(100, number);
    }
    @After
    public void clearNumber() {
        number=0;
    }
    @AfterClass
    public static void afterClass() {
        staticNumber = null;
    }
}

assertThat([값], [matcher 문법])

String actual = "A";
assertEquals("A", actual);

String actual = "A";
assertThat(actual , is("A")); 
//That actual is "A"

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.matchers.JUnitMatchers.containsString;
public class SimpleTest {
        String responseString = "color col";
        @Test
        public void usingAssertTrue() {
                assertTrue(responseString.contains("color") && responseString.contains("colour"));
        }
        @Test
        public void usingAssertThat() {
                assertThat(responseString, is(allOf(containsString("color"), containsString("colour"))));
                // That responseString is a containning string "color" and a containning string "colour".
        }
}

import static org.hamcrest.CoreMatchers.*;
import static org.junit.matchers.JUnitMatchers.*;

public void test1(){
        if(new File(EXAMPLE_PATH).exists() == false)
                return;
        // ... 테스트 코드
}

@Before
public void before(){
        Assume.assumeThat(new File(EXAMPLE_PATH).exists(), is(true));
}
@Test
public void test1(){
        FileReader fr = new FileReader(EXAMPLE_PATH);
        // ... 테스트 코드
}

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
import static org.junit.Assume.assumeThat;
import static org.junit.matchers.StringContains.containsString;
import org.junit.experimental.theories.DataPoint;
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.experimental.theories.suppliers.TestedOn;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class TheoryExample {
        public class User {
                private String username;
                public User(String username) {
                        this.username = username;
                }
                public String getUsername(){
                        return this.username;
                }
        }
        @DataPoint public static String GOOD_USERNAME = "optimus";
        @DataPoint public static String USERNAME_WITH_SLASH = "optimus/prime";
        @Theory
        public void filenameIncludesUsername(String username) {
                assumeThat(username, not(containsString("/")));
                assertThat(new User(username).getUsername(), containsString(username));
        }
        @SuppressWarnings("unchecked")
        @Theory
        public void multiplyIsInverseOfDivideWithInlineDataPoints(
                        @TestedOn(ints = { 0, 5, 10 }) int amount,
                        @TestedOn(ints = { 0, 1, 2 })  int m) {
                assumeThat(m, not(0));
                assertThat(amount*m/m, is(amount));
        }
}

public class AllTests {
        public static Test suite() {
                TestSuite suite = new TestSuite("Test for default package");
                //$JUnit-BEGIN$
                suite.addTestSuite(SimpleTest.class);
                //$JUnit-END$
                return suite;
        }
}

package test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses( { SimpleTest.class,SimpleTest2.class})
public class AllTests {
}

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
...
assertThat("A", is("A");
...

String example = "example";