Junit 断言 assertThat Hamcrest匹配器

junit断言总结

本文参考了http://blog.csdn.net/wangpeng047/article/details/9628449

一 junit断言
1.JUnit框架用一组assert方法封装了最常见的测试任务。这些assert方法可以极大地简化单元测试的编写。
Assert类包含了一组静态的测试方法，用于验证期望值expected和实际值actual逻辑比对是否正确，即测试失败，标志为未通过测试。
如果期望值和实际值比对失败，Assert类就会抛出一个AssertionFailedError异常，Junit测试框架将这种错误归入Fails并且加以记录。
每一个Assert类所属的方法都会被重载(OverLoaded)，如果指定了一个String类型的传参则该参数将被做为AssertionFailedError异常的标识信息，告诉测试人员该异常的具体信息。
定义assert方法的辅助类的名称：Assert类。这个类包含了很多对于编写测试很有用的具体代码。
2.核心断言方法：
assertArrayEquals(expecteds, actuals)     查看两个数组是否相等。
assertEquals(expected, actual)     查看两个对象是否相等。类似于字符串比较使用的equals()方法
assertNotEquals(first, second)     查看两个对象是否不相等。
assertNull(object)     查看对象是否为空。
assertNotNull(object)     查看对象是否不为空。
assertSame(expected, actual)     查看两个对象的引用是否相等。类似于使用“==”比较两个对象
assertNotSame(unexpected, actual)     查看两个对象的引用是否不相等。类似于使用“!=”比较两个对象
assertTrue(condition)     查看运行结果是否为true。
assertFalse(condition)     查看运行结果是否为false。
assertThat(actual, matcher)     查看实际值是否满足指定的条件
fail()     让测试失败
3.注解：
@Before     初始化方法
@After     释放资源
@Test     测试方法，在这里可以测试期望异常和超时时间
@Ignore     忽略的测试方法
@BeforeClass     针对所有测试，只执行一次，且必须为static void
@AfterClass     针对所有测试，只执行一次，且必须为static void
@RunWith     指定测试类使用某个运行器
@Parameters     指定测试类的测试数据集合
@Rule     允许灵活添加或重新定义测试类中的每个测试方法的行为
@FixMethodOrder     指定测试方法的执行顺序
一个测试类单元测试的执行顺序为：
@BeforeClass –> @Before –> @Test –> @After –> @AfterClass
4.基本用法：

package test;  

    import static org.hamcrest.CoreMatchers.*;
    import static org.junit.Assert.*;
    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())));
          }
    }  

二 assertThat的用法

1.一些基本的断言，如eqaul,null,true它们的可读性并不是很好，有时我们不得不自己编写表达式并断言其结果，并且因为我们没有提供失败的信息，当这个断言失败时只会抛出java.lang.AssertionError，无法知道到底是哪一部分出错。
JUnit4.4引入了Hamcrest框架，Hamcest提供了一套匹配符Matcher，这些匹配符更接近自然语言，可读性高，更加灵活。并且使用全新的断言语法：assertThat，结合Hamcest提供的匹配符，只用这一个方法，就可以实现所有的测试。
2.assertThat语法如下：
assertThat(T actual, Matcher matcher);
assertThat(String reason, T actual, Matcher matcher); 
其中reason为断言失败时的输出信息，actual为断言的值或对象，matcher为断言的匹配器，里面的逻辑决定了给定的actual对象满不满足断言
3.注意事项：
a.必须导入JUnit4.4之后的版本以及hamcrest-core.jar和hamcrest-library.jar才能使用assertThat方法； b.不需要继承TestCase类，但是需要测试方法前必须加“@Test”。 
c.要用junit中的assertThat来进行断言，记住静态导入:
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

三 Hamcrest匹配器的用法

Hamcrest是一个测试的框架，它提供了一套通用的匹配符Matcher，灵活使用这些匹配符定义的规则，程序员可以更加精确的表达自己的测试思想，指定所想设定的测试条件。
hamcrest常用的匹配器:
核心：
    anything - 总是匹配,如果你不关心测试下的对象是什么是有用的
    describedAs - 添加一个定制的失败表述装饰器
    is - 改进可读性装饰器 - 见下 “Sugar”
逻辑：
    allOf - 如果所有匹配器都匹配才匹配,像Java里的&&
    anyOf - 如果任何匹配器匹配就匹配,像Java里的||
    not - 如果包装的匹配器不匹配器时匹配,反之亦然
对象：
    equalTo - 测试对象相等使用Object.equals方法
    hasToString - 测试Object.toString方法
    instanceOf, isCompatibleType - 测试类型
    notNullValue, nullValue - 测试null
    sameInstance - 测试对象实例
Beans：
    hasProperty - 测试JavaBeans属性
集合：
    array - 测试一个数组元素test an array’s elements against an array of matchers
    hasEntry, hasKey, hasValue - 测试一个Map包含一个实体,键或者值
    hasItem, hasItems - 测试一个集合包含一个元素
    hasItemInArray - 测试一个数组包含一个元素
数字：
    closeTo - 测试浮点值接近给定的值
    greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo - 测试次序
文本：
    equalToIgnoringCase - 测试字符串相等忽略大小写
    equalToIgnoringWhiteSpace - 测试字符串忽略空白
    containsString, endsWith, startsWith - 测试字符串匹配

举个例子：

　　　　@Test
     public void testHamcrest(){
         // 比较50是否和50相等
         assertThat(50, equalTo(50));
        // 50是否大于30并且小于60
        assertThat("错误",50, allOf(greaterThan(30), lessThan(60)));
        // 判断字符串是否以.txt结尾
        assertThat("错误", "abc.txt", endsWith(".txt"));
     }

四 TestSuite
如果有多个测试操作类，那么一个一个来运行测试就很不方便，所以通过testsuit可以把多个测试类“捆绑”起来，一起测试！
例如，一个工程有三个测试类，TestA, TestB和TestCalculate，我们可以再建一个类TestSuit，把这些类进行打包，然后同时运行测试。

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

// RunWith表示这个类是一个suite的类
@RunWith(Suite.class)
// 说明这个类中包含哪些测试组建
@SuiteClasses({TestA.class,
               TestB.class,
               TestCalculate.class})
public class TestSuit {
    /*
     *  测试原则：
     *  1、建议创建一个专门的source folder--->test来编写测试类代码
     *  2、测试类的包应该保持和需要测试的类一致
     *  3、测试单元中的每个测试方法都必须可以独立执行，没有次序，不能有任何互相依赖
     */

}

然后直接运行TestSuit这个类就可以测试所选的测试类了。