【单元测试】Junit 4（三）--Junit4断言-Toy模板网

这篇具有很好参考价值的文章主要介绍了【单元测试】Junit 4（三）--Junit4断言。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.0 前言

**断言(assertion)**是一种在程序中的一阶逻辑(如：一个结果为真或假的逻辑判断式)，目的为了表示与验证软件开发者预期的结果——当程序执行到断言的位置时，对应的断言应该为真。若断言不为真时，程序会中止执行，并给出错误信息。

1.1 JUnit assert断言

这里我们直接上例子

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import org.junit.Test;

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

  @Test
  public void testAssertEquals() {
    assertEquals("failure - strings are not equal", "text", "text");
  }

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

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

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

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

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

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

接下来我们来介绍下他们

方法	介绍
assertEquals(expected, actual)	检查断言两个值相等
assertTrue(condition)	检查条件为真
assertFalse(condition)	检查条件为假
assertNotNull(object)	检查不为空
assertNull(object)	检查为空
assertNotSame(expected, actual)	检查两个相关对象是否不指向同一个对象
assertSame(expected, actual)	检查两个相关对象是否指向同一个对象
assertArrayEquals(expectedArray, resultArray)	检查两个数组是否相等

1.2 assertThat断言

1.2.0 assertThat介绍

JUnit 4 结合 Hamcrest 提供了一个全新的断言语法——assertThat。程序员可以只使用 assertThat 一个断言语句，结合 Hamcrest 提供的匹配符，就可以表达全部的测试思想

1.2.1 一般匹配符断言

方法	介绍
assertThat(“myValue”, allOf(startsWith(“my”), containsString(“Val”)))	allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&）
assertThat(“myValue”, anyOf(startsWith(“foo”), containsString(“Val”)))	anyOf匹配符表明如果接下来的所有条件只要有一个成立则测试通过，相当于“或”（
assertThat( “myValue”, anything() )	anything匹配符表明无论什么条件，永远为true
assertThat( “myValue”, is( “myValue” ) )	is匹配符表明如果前面待测的值等于后面给出的值，则测试通过
assertThat( “myValue”, not(“foo”))	not匹配符和is匹配符正好相反，表明如果前面待测的值不等于后面给出的值，则测试通过

1.2.2 字符串相关匹配符

方法	介绍
assertThat(“myStringOfNote”, containsString(“ring”))	containsString匹配符表明如果测试的字符串包含子字符串则测试通过
assertThat(“myStringOfNote”, endsWith(“Note”))	endsWith匹配符表明如果测试的字符串以子字符串结尾则测试通过
assertThat(“myStringOfNote”, startsWith(“my”))	startsWith匹配符表明如果测试的字符串以子字符串开始则测试通过
assertThat(“foo”, equalTo(“foo”))	equalTo匹配符表明如果测试的数据等于则测试通过，equalTo可以测试数值之间，字符串之间和对象之间是否相等，相当于Object的equals方法
assertThat(“Foo”, equalToIgnoringCase(“FOO”))	equalToIgnoringCase匹配符表明如果测试的字符串在忽略大小写的情况下等于则测试通过
assertThat(" my\tfoo bar “, equalToIgnoringWhiteSpace(” my foo bar"))	equalToIgnoringWhiteSpace匹配符表明如果测试的字符串在忽略头尾的任意个空格的情况下等于则测试通过，注意：字符串中的空格不能被忽略

1.2.3 数值相关匹配符

方法	介绍
assertThat(1.03, is(closeTo(1.0, 0.03)))	closeTo匹配符表明如果所测试的浮点型数在1.0±0.03范围之内则测试通过
assertThat(2, greaterThan(1))	greaterThan匹配符表明如果所测试的数值大于1则测试通过
assertThat(1, lessThan(2))	lessThan匹配符表明如果所测试的数值小于2则测试通过
assertThat(1, greaterThanOrEqualTo(1))	greaterThanOrEqualTo匹配符表明如果所测试的数值大于等于1则测试通过
assertThat(1, lessThanOrEqualTo(1))	lessThanOrEqualTo匹配符表明如果所测试的数值小于等于1则测试通过

1.2.4 集合相关匹配符

方法	介绍
assertThat(myMap, hasEntry(“bar”, “foo”))	hasEntry匹配符表明如果测试的Map对象含有一个键值为"bar"对应元素值为"foo"的Entry项则测试通过
ssertThat(Arrays.asList(“foo”, “bar”), hasItem(startsWith(“ba”)))	hasItem匹配符表明如果测试的迭代对象含有元素以ba开头项则测试通过
assertThat(myMap, hasKey(“bar”))	hasKey匹配符表明如果测试的Map对象含有键值“bar”则测试通过
assertThat(myMap, hasValue(“foo”))	hasValue匹配符表明如果测试的Map对象含有元素值“foo”则测试通过

1.2.5 示例

Cs.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Cs {
 
public int add(int a, int b) {
 
   return a + b;
}
 
public double div(double a, double b) {
 
   return a / b;
}
 
public String getName(String name) {
 
   return name;
}
 
public List<String> getList(String item) {
 
   List<String> l = new ArrayList<String>();
   l.add(item);
   return l;
}
 
public Map<String, String> getMap(String key, String value) {
 
   Map<String, String> m = new HashMap<String, String>();
   m.put(key, value);
   return m;
}
}

CsTest.java

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;

import java.util.List;
import java.util.Map;
import org.junit.Test;
 
public class CsTest {

@Test
public void testAdd() {
 
   //一般匹配符 
   int s = new Cs().add(1, 1);
   //allOf：所有条件必须都成立，测试才通过 
   assertThat(s, allOf(greaterThan(1), lessThan(3)));
   //anyOf：只要有一个条件成立，测试就通过 
   assertThat(s, anyOf(greaterThan(1), lessThan(1)));
   //anything：无论什么条件，测试都通过 
   assertThat(s, anything());
   //is：变量的值等于指定值时，测试通过 
   assertThat(s, is(2));
   //not：和is相反，变量的值不等于指定值时，测试通过 
   assertThat(s, not(1));
 
   //数值匹配符 
   double d = new Cs().div(10, 3);
   //closeTo：浮点型变量的值在3.0±0.5范围内，测试通过 
   assertThat(d, closeTo(3.0, 0.5));
   //greaterThan：变量的值大于指定值时，测试通过 
   assertThat(d, greaterThan(3.0));
   //lessThan：变量的值小于指定值时，测试通过 
   assertThat(d, lessThan(3.5));
   //greaterThanOrEuqalTo：变量的值大于等于指定值时，测试通过 
   assertThat(d, greaterThanOrEqualTo(3.3));
   //lessThanOrEqualTo：变量的值小于等于指定值时，测试通过 
   assertThat(d, lessThanOrEqualTo(3.4));
 
   //字符串匹配符 
   String n = new Cs().getName("Magci");
   //containsString：字符串变量中包含指定字符串时，测试通过 
   assertThat(n, containsString("ci"));
   //startsWith：字符串变量以指定字符串开头时，测试通过 
   assertThat(n, startsWith("Ma"));
   //endsWith：字符串变量以指定字符串结尾时，测试通过 
   assertThat(n, endsWith("i"));
   //euqalTo：字符串变量等于指定字符串时，测试通过 
   assertThat(n, equalTo("Magci"));
   //equalToIgnoringCase：字符串变量在忽略大小写的情况下等于指定字符串时，测试通过 
   assertThat(n, equalToIgnoringCase("magci"));
   //equalToIgnoringWhiteSpace：字符串变量在忽略头尾任意空格的情况下等于指定字符串时，测试通过 
   assertThat(n, equalToIgnoringWhiteSpace(" Magci   "));
 
   //集合匹配符 
   List<String> l = new Cs().getList("Magci");
   //hasItem：Iterable变量中含有指定元素时，测试通过 
   assertThat(l, hasItem("Magci"));
 
   Map<String, String> m = new Cs().getMap("mgc", "Magci");
   //hasEntry：Map变量中含有指定键值对时，测试通过 
   assertThat(m, hasEntry("mgc", "Magci"));
   //hasKey：Map变量中含有指定键时，测试通过 
   assertThat(m, hasKey("mgc"));
   //hasValue：Map变量中含有指定值时，测试通过 
   assertThat(m, hasValue("Magci"));
}
}