Coding ManHamcrest中CoreMatchers简介
1. 概述
在本快速教程中，我们将探索 流行的Hamcrest 框架中的CoreMatchers类 ，以编写简单且更具表现力的测试用例。
这个想法是让 assert 语句读起来像自然语言。
2. Hamcrest 设置
我们可以通过将以下依赖项添加到我们的 pom.xml 文件来将 Hamcrest 与 Maven 一起使用：
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>java-hamcrest</artifactId>
<version>2.0.0.0</version>
<scope>test</scope>
</dependency>
这个库的最新版本总是可以在这里 找到。
3. 通用核心匹配器
3.1. is(T) 和 is(Matcher<T>)
is(T)将一个对象作为参数来检查是否相等，而is(Matcher<T>) 采用另一个匹配器，使相等语句更具表现力。
我们可以将其与几乎所有方法一起使用：
String testString = "hamcrest core";
assertThat(testString, is("hamcrest core"));
assertThat(testString, is(equalTo("hamcrest core")));
3.2. equalTo(T)
equalTo(T)将一个对象作为参数并检查它是否与另一个对象相等。**这经常与is(Matcher<T>)一起使用：
String actualString = "equalTo match";
List<String> actualList = Lists.newArrayList("equalTo", "match");
assertThat(actualString, is(equalTo("equalTo match")));
assertThat(actualList, is(equalTo(Lists.newArrayList("equalTo", "match"))));
我们还可以使用equalToObject(Object operand) – 它检查相等性并且不强制两个对象应该具有相同的静态类型：
Object original = 100;
assertThat(original, equalToObject(100));
3.3. not(T) 和 not(Matcher<T>)
not(T) 和 not(Matcher<T>) 用于检查给定对象的不相等性。首先将一个对象作为参数，然后将另一个匹配器作为参数：
String testString = "troy kingdom";
assertThat(testString, not("german kingdom"));
assertThat(testString, is(not(equalTo("german kingdom"))));
assertThat(testString, is(not(instanceOf(Integer.class))));
3.4. nullValue() 和 nullValue(Class<T>)
*nullValue()针对被检查的对象检查空 值。*nullValue(Class<T>)*检查给定类类型对象的可空性：
Integer nullObject = null;
assertThat(nullObject, is(nullValue()));
assertThat(nullObject, is(nullValue(Integer.class)));
3.5. notNullValue() 和 notNullValue(Class<T>)
**这些是常用的*is(not(nullValue))*的快捷方式。**这些检查对象或类类型的非空相等性：
Integer testNumber = 123;
assertThat(testNumber, is(notNullValue()));
assertThat(testNumber, is(notNullValue(Integer.class)));
3.6. instanceOf(Class<?>)
如果检查的对象是指定Class类型的实例，则instanceOf(Class<?*>)*匹配。
为了验证，这个方法内部调用了Class类的isIntance(Object)：
assertThat("instanceOf example", is(instanceOf(String.class)));
3.7. isA(Class<T> type)
isA(Class<T> type) 是上述instanceOf(Class<?>)的快捷方式。**它采用与instanceOf(Class<?*>)完全相同类型的参数*：
assertThat("Drogon is biggest dragon", isA(String.class));
3.8. sameInstance()
如果两个引用变量指向堆中的同一个对象，则*sameInstance()*匹配：
String string1 = "Viseron";
String string2 = string1;
assertThat(string1, is(sameInstance(string2)));
3.9. any(Class<T>)
*any(Class<T>)*检查类是否与实际对象属于同一类型：
assertThat("test string", is(any(String.class)));
assertThat("test string", is(any(Object.class)));
3.10. allOf(Matcher<? extends T*>…)* 和 anyOf(Matcher<? extends T*>…)*
我们可以使用allOf(Matcher<? extends T*>…)* 断言实际对象是否匹配所有指定条件：
String testString = "Achilles is powerful";
assertThat(testString, allOf(startsWith("Achi"), endsWith("ul"), containsString("Achilles")));
anyOf ( Matcher < ？
String testString = "Hector killed Achilles";
assertThat(testString, anyOf(startsWith("Hec"), containsString("blogdemo")));
3.11. hasItem(T)和hasItem(Matcher<? extends T*>)*
如果检查的Iterable集合与*hasItem()或 hasItem(Matcher<? extends T>)*中的给定对象或匹配器匹配，则这些匹配。
让我们了解这是如何工作的：
List<String> list = Lists.newArrayList("java", "spring", "blogdemo");
assertThat(list, hasItem("java"));
assertThat(list, hasItem(isA(String.class)));
同样，我们也可以 使用hasItems(T…)和hasItems(Matcher<? extends T>…)对多个项目进行断言：
List<String> list = Lists.newArrayList("java", "spring", "blogdemo");
assertThat(list, hasItems("java", "blogdemo"));
assertThat(list, hasItems(isA(String.class), endsWith("ing")));
3.12. both(Matcher<? extends T*>)* 和 either(Matcher<? extends T*>)*
顾名思义，both(Matcher<? extends T*>)*在两个指定条件都匹配检查对象时匹配：
String testString = "daenerys targaryen";
assertThat(testString, both(startsWith("daene")).and(containsString("yen")));
并且 either(Matcher<? extends T*>)*在任一指定条件与检查的对象匹配时匹配：
String testString = "daenerys targaryen";
assertThat(testString, either(startsWith("tar")).or(containsString("targaryen")));
4. String比较
我们可以使用containsString(String) 或*containsStringIgnoringCase(String)*来断言实际字符串是否包含测试字符串：
String testString = "Rhaegar Targaryen";
assertThat(testString, containsString("aegar"));
assertThat(testString, containsStringIgnoringCase("AEGAR"));
或者 *startsWith(String)*和 *startsWithIgnoringCase(String)*断言实际字符串是否以测试字符串开头：
assertThat(testString, startsWith("Rhae"));
assertThat(testString, startsWithIgnoringCase("rhae"));
我们还可以使用 *endsWith(String)*或 endsWithIgnoringCase(String) 来断言实际字符串是否以测试字符串结尾：
assertThat(testString, endsWith("aryen"));
assertThat(testString, endsWithIgnoringCase("ARYEN"));