【原創】Junit4詳解一：Junit總體介紹

    Junit是一個可編寫重復測試的簡單框架，是基於Xunit架構的單元測試框架的實例。Junit4最大的改進是大量使用注解（元數據），很多實際執行過程都在Junit的后台做完了，而且寫test case 的類不需要繼承TestCase，只需要在所要做test case的方法前加@Test 注解即可。

如：

import static org.junit.Assert.*;
2 public class TestCaculatorClass {
3     @Test
4     public void test() throws IOException, RuntimeException{
5         CaculatorClassForTest cal = new CaculatorClassForTest();
6         assertEquals(30, cal.sum(10, 20));
7     }
8 }

直接點擊右鍵，run as... Junit Test即可運行此test case。

Assert類里面有很多assert方法，包括：assertEquals()， assertNotNull()，assertTtrue()，assertFalse()，assertThat()等，其中assertThat用的是match的形式。

因此，Junit提供很多中Match，其中CoreMatchers是其中一個比較完善的實現類。具體有上面方法可以查閱CoreMatchers類。

import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.both;
import static org.junit.matchers.JUnitMatchers.containsString;
import static org.junit.matchers.JUnitMatchers.everyItem;
import static org.junit.matchers.JUnitMatchers.hasItems;

import java.util.Arrays;

import org.hamcrest.core.CombinableMatcher;
import org.junit.Test;

public class AssertTests {
  @Test
  public void testAssertArrayEquals() {
    byte[] expected = "trial".getBytes();
    byte[] actual = "trial".getBytes();
    org.junit.Assert.assertArrayEquals("failure - byte arrays not same", expected, actual);
  }

  @Test
  public void testAssertEquals() {
    org.junit.Assert.assertEquals("failure - strings not same", 5l, 5l);
  }

  @Test
  public void testAssertFalse() {
    org.junit.Assert.assertFalse("failure - should be false", false);
  }

  @Test
  public void testAssertNotNull() {
    org.junit.Assert.assertNotNull("should not be null", new Object());
  }

  @Test
  public void testAssertNotSame() {
    org.junit.Assert.assertNotSame("should not be same Object", new Object(), new Object());
  }

  @Test
  public void testAssertNull() {
    org.junit.Assert.assertNull("should be null", null);
  }

  @Test
  public void testAssertSame() {
    Integer aNumber = Integer.valueOf(768);
    org.junit.Assert.assertSame("should be same", aNumber, aNumber);
  }

  // JUnit Matchers assertThat
  @Test
  public void testAssertThatBothContainsString() {
    org.junit.Assert.assertThat("albumen", both(containsString("a")).and(containsString("b")));
  }

  @Test
  public void testAssertThathasItemsContainsString() {
    org.junit.Assert.assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
  }

  @Test
  public void testAssertThatEveryItemContainsString() {
    org.junit.Assert.assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
  }

  // Core Hamcrest Matchers with assertThat
  @Test
  public void testAssertThatHamcrestCoreMatchers() {
    assertThat("good", allOf(equalTo("good"), startsWith("good")));
    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
    assertThat(new Object(), not(sameInstance(new Object())));
  }

  @Test
  public void testAssertTrue() {
    org.junit.Assert.assertTrue("failure - should be true", true);
  }
}

問題一，我可不可以把多個測試類放在一起執行？

回答： 可以。org.junit.runner.JUnitCore.runClasses(TestClass1.class, ...);利用這樣，把test case 的類放進去，然后放在main()方法里執行。

問題二，@RunWith這個注解有什么作用？

回答：Junit4的默認runner為BlockJunit4ClassRunner，但是Junit4包括第三方軟件還提供很多其他的runner，這樣如果，我們想讓我們的測試類用專門的runner來運行，這時候就可以用@RunWith(Suit.class

)標注測試類。其他特殊的runner有：

1. Suite： 字面理解是一個套裝，通俗地講，就是你可以把很多測試類放在一起，然后建一個類，標注為Suite.class，那么如果執行這個類，就會把所有的測試類一起執行。

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({
  TestFeatureLogin.class,
  TestFeatureLogout.class,
  TestFeatureNavigate.class,
  TestFeatureUpdate.class
})

public class FeatureTestSuite {
  // the class remains empty,
  // used only as a holder for the above annotations
}

 

2. Parameterized：根據所設計的參數來執行測試。假設我們要測試某一個方法，它有兩個參數，每個參數需要設計不同值，那么我們最開始就是需要為每個參數設計一個測試方法，這樣就很麻煩，10種case就得10個方法，但是有了Parameterized runner，我們可以設計一個方法，多種參數來執行test case。

package com.citi.risk.core.test.impl;

public class CaculatorClassForTest {
    
    private int o1;
    private int o2;
    public int getO1() {
        return this.o1;
    }
    public void setO1(int value) {
        this.o1 = value;
    }
    public int getO2() {
        return this.o2;
    }
    public void setO2(int value) {
        this.o2 = value;
    }
    
    
    public CaculatorClassForTest() {}
    public CaculatorClassForTest(int o1, int o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    
    public int sum(int o1, int o2){
        if(o1 > 200) {
            throw new RuntimeException("o1 is too big");
        }
        if(o2 > 200) {
            throw new RuntimeException("o2 is too big");
        }
        int sum;
        sum = o1 + o2;
        return sum;
    }
}

 

 

package com.citi.risk.core.test.impl;

import static org.junit.Assert.*;

import java.io.IOException;
import java.util.List;

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;

import com.google.common.collect.Lists;

@RunWith(Parameterized.class)
public class TestCaculatorClass {
    @Rule
    public ExpectedException thrown = ExpectedException.none();
    
    @Parameters
    public static List<Object[]> data() {
        return Lists.asList(new Object[]{-1, 1, 0}, new Object[][]{{20, 20, 40},{30, 30, 60},{-5, -5, -10}});
    }
    @Parameter(value = 0)
    public int o1;
    @Parameter(value = 1)
    public int o2;
    @Parameter(value = 2)
    public int expector;
    
    @Test
    public void test() throws IOException, RuntimeException{
        CaculatorClassForTest cal = new CaculatorClassForTest();
        assertEquals(expector, cal.sum(o1, o2));
    }
    
    @Test
    public void testO1Exception(){
        CaculatorClassForTest cal = new CaculatorClassForTest();
        thrown.expect(RuntimeException.class);
        thrown.expectMessage("o1 is too big");
        cal.sum(300, 100);
    }
    @Test
    public void testO2Exception(){
        CaculatorClassForTest cal = new CaculatorClassForTest();
        thrown.expect(RuntimeException.class);
        thrown.expectMessage("o2 is too big");
        cal.sum(100, 300);
    }
    
}

 

 以上兩個類就是測試了Parameterized runner， 參數會自動匹配。它其實就是，看我們傳入幾種case， 也就是List.size()，然后，把類里面的方法，循環重復執行size()數目。

3. Categories：容易理解就是分類執行。假設我們有一種case： 我們寫好了兩個測試類，類A，類B，A有兩個方法a(), b(),這時候我們有一個類來執行這兩個類的test case，但是我們在類A里只想執行A.b()，但卻不執行A.a()，這個時候我們可以用Categories runner。

public interface FastTests { /* category marker */ }
public interface SlowTests { /* category marker */ }

public class A {
  @Test
  public void a() {
    fail();
  }

  @Category(SlowTests.class)
  @Test
  public void b() {
  }
}

@Category({SlowTests.class, FastTests.class})
public class B {
  @Test
  public void c() {

  }
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestSuite {
  // Will run A.b and B.c, but not A.a
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@ExcludeCategory(FastTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestSuite {
  // Will run A.b, but not A.a or B.c
}

4. Enclosed：如果我們把tests放在了內部類，這時候執行外部類是無法執行里面的test cases，這種情況下，就應該在outer class 用Enclosed runner。

要測試的類 Address：

package abstractions.domain;

    import java.io.Serializable;

    import com.google.common.collect.ComparisonChain;

    public class Address implements Serializable, Comparable<Address> {

        private static final long serialVersionUID = 1L;
        private final String address1;
        private final String city;
        private final String state;
        private final String zip;

        private Address(Builder builder) {
            this.address1 = builder.address1;
            this.city = builder.city;
            this.state = builder.state;
            this.zip = builder.zip;
        }

        public String getAddress1() {
            return address1;
        }

        public String getCity() {
            return city;
        }

        public String getState() {
            return state;
        }

        public String getZip() {
            return zip;
        }

        @Override
        public int compareTo(Address that) {
            return ComparisonChain.start().compare(this.zip, that.zip).compare(this.state, that.state)
                    .compare(this.city, that.city).compare(this.address1, that.address1).result();
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) { return false; }
            if (getClass() != obj.getClass()) { return false; }
            final Address that = (Address) obj;

            return com.google.common.base.Objects.equal(this.address1, that.address1)
                    && com.google.common.base.Objects.equal(this.city, that.city)
                    && com.google.common.base.Objects.equal(this.state, that.state)
                    && com.google.common.base.Objects.equal(this.zip, that.zip);
        }

        @Override
        public int hashCode() {
            return com.google.common.base.Objects.hashCode(getAddress1(), getCity(), getCity(), getState(), getZip());
        }

        @Override
        public String toString() {
            return com.google.common.base.Objects.toStringHelper(this).addValue(getAddress1()).addValue(getCity()).addValue(getState()).addValue(getZip()).toString();
        }

        public static class Builder {

            private String address1;
            private String city;
            private String state;
            private String zip;

            public Builder address1(String address1) {
                this.address1 = address1;
                return this;
            }

            public Address build() {
                return new Address(this);
            }

            public Builder city(String city) {
                this.city = city;
                return this;
            }

            public Builder state(String state) {
                this.state = state;
                return this;
            }

            public Builder zip(String zip) {
                this.zip = zip;
                return this;
            }
        }
    }

test case：

package abstractions.domain;

    import static org.hamcrest.Matchers.is;
    import static org.junit.Assert.assertThat;

    import java.io.Serializable;

    import org.junit.Before;
    import org.junit.Test;
    import org.junit.experimental.runners.Enclosed;
    import org.junit.runner.RunWith;

    import testhelpers.ComparabilityTestCase;
    import testhelpers.EqualsHashCodeTestCase;
    import testhelpers.SerializabilityTestCase;

    /**
     * The Class AddressTest.
     */
    @RunWith(Enclosed.class)
    public class AddressTest {

        /**
         * The Class AddressComparabilityTest.
         */
        public static class AddressComparabilityTest extends ComparabilityTestCase<Address> {

            @Override
            protected Address createEqualInstance() throws Exception {
                return new Address.Builder().address1("2802 South Havana Street").city("Aurora").state("CO").zip("80014").build();
            }

            @Override
            protected Address createGreaterInstance() throws Exception {
                return new Address.Builder().address1("9839 Carlisle Boulevard NE").city("Albuquerque").state("NM").zip("87110").build();
            }

            @Override
            protected Address createLessInstance() throws Exception {
                return new Address.Builder().address1("14 Broad St").city("Nashua").state("NH").zip("03064").build();
            }
        }

        /**
         * The Class AddressEqualsHashCodeTest.
         */
        public static class AddressEqualsHashCodeTest extends EqualsHashCodeTestCase {

            @Override
            protected Address createInstance() throws Exception {
                return new Address.Builder().address1("2802 South Havana Street").city("Aurora").state("CO").zip("80014").build();
            }

            @Override
            protected Address createNotEqualInstance() throws Exception {
                return new Address.Builder().address1("9839 Carlisle Boulevard NE").city("Albuquerque").state("NM").zip("87110").build();
            }
        }

        /**
         * The Class AddressSerializabilityTest.
         */
        public static class AddressSerializabilityTest extends SerializabilityTestCase {

            @Override
            protected Serializable createInstance() throws Exception {
                return new Address.Builder().address1("9839 Carlisle Boulevard NE").city("Albuquerque").state("NM").zip("87110").build();
            }
        }

        public static class AddressMiscTest {

            private Address address;

            /**
             * Setup.
             *
             * @throws Exception the exception
             */
            @Before
            public void setUp() throws Exception {
                address = new Address.Builder().address1("9839 Carlisle Boulevard NE").city("Albuquerque").state("NM").zip("87110").build();
            }

            /**
             * Test builder.
             */
            @Test
            public void testBuilder() {
                assertThat(address.getAddress1(), is("9839 Carlisle Boulevard NE"));
                assertThat(address.getCity(), is("Albuquerque"));
                assertThat(address.getState(), is("NM"));
                assertThat(address.getZip(), is("87110"));
            }

            @Test
            public void testToString() {
                assertThat(address.toString(), is("Address{9839 Carlisle Boulevard NE, Albuquerque, NM, 87110}"));
            }
        }
    }

問題三：不想執行某個類的test case 有什么方法？

回答： 用@Ignore， 如果要讓某個類都不執行，@Ignore放在類里，如果不想執行某一個方法，只需要放在方法上。

@Ignore
public class TestClass{

    @Ignore("Test is ignored as a demonstration")
    @Test
    public void testSane() {
        assertThat(1, is(1));
    }
}

問題四：某個test case執行時間太長，有什么辦法終止？

回答： Junit4提供了timeout屬性。

@Test(timeout=1000)
public void testWithTimeout() {
  ...
}

 

Junit4還有更重要的@Rule 和 執行順序。且聽下回分解。

 

草原戰狼淘寶小店：http://xarxf.taobao.com/ 淘寶搜小矮人鞋坊，主營精致美麗時尚女鞋，為您的白雪公主挑一雙哦。謝謝各位博友的支持。

===============================================================================

==========================    以上分析僅代表個人觀點，歡迎指正與交流   ==========================

==========================    草原戰狼博客，轉載請注明出處，萬分感謝   ==========================

===============================================================================