Hamcrest 1.3

Hamcrest version: 1.3

##### Base matchers

- [equalTo](#equalto)
- [is](#is)
- [isA](#isa)
- [typeCompatibleWith](#typecompatiblewith)
- [anything](#anything)
- [any](#any)
- [instanceOf](#instanceof)
- [sameInstance](#sameinstance)
- [theInstance](#theinstance)
- [not](#not)
- [nullValue](#nullvalue)
- [notNullValue](#notnullvalue)
- [describedAs](#describedas)

##### Comparables

- [comparesEqualTo](#comparesequalto)
- [lessThan](#lessthan)
- [lessThanOrEqualTo](#lessthanorequalto)
- [greaterThan](#greaterthan)
- [greaterThanOrEqualTo](#greaterthanorequalto)

##### Arrays

- [emptyArray](#emptyarray)
- [arrayWithSize](#arraywithsize)
- [array](#array)
- [hasItemInArray](#hasiteminarray)
- [arrayContaining](#arraycontaining)
- [arrayContainingInAnyOrder](#arraycontaininginanyorder)

##### Sequences

- [empty](#empty)
- [emptyCollectionOf](#emptycollectionof)
- [emptyIterable](#emptyiterable)
- [emptyIterableOf](#emptyiterableof)
- [hasSize](#hassize)
- [contains](#contains)
- [containsInAnyOrder](#containsinanyorder)
- [iterableWithSize](#iterablewithsize)
- [isIn](#isin)
- [isOneOf](#isoneof)
- [everyItem](#everyitem)
- [hasItem](#hasitem)
- [hasItems](#hasitems)

##### Maps

- [hasEntry](#hasentry)
- [hasKey](#haskey)
- [hasValue](#hasvalue)

##### Combiners

- [allOf](#allof)
- [anyOf](#anyof)
- [both](#both)
- [either](#either)

##### Strings

- [isEmptyString](#isemptystring)
- [isEmptyOrNullString](#isemptyornullstring)
- [startsWith](#startswith)
- [endsWith](#endswith)
- [containsString](#containsstring)
- [equalToIgnoringCase](#equaltoignoringcase)
- [equalToIgnoringWhiteSpace](#equaltoignoringwhitespace)
- [stringContainsInOrder](#stringcontainsinorder)

##### Numbers

- [closeTo](#closeto)

### Base matchers

##### equalTo

```java
assertThat(10, equalTo(10));
```

##### is

```java
assertThat(10, is(10));
assertThat(10, is(greaterThan(5)));
```

##### isA

```java
assertThat(10, isA(Integer.class));
```

##### typeCompatibleWith

```java
assertThat(Integer.class, typeCompatibleWith(Number.class));
```

##### anything

```java
assertThat(10, anything());
```

##### any

```java
assertThat(10, any(Integer.class));
```

##### instanceOf

```java
assertThat(10, instanceOf(Integer.class));
```

##### sameInstance

```java
BigDecimal bigDecimal = new BigDecimal("10.01");
assertThat(new BigDecimal("10.01"), not(sameInstance(bigDecimal)));
```

##### theInstance

```java
BigDecimal bigDecimal = new BigDecimal("10.01");
assertThat(new BigDecimal("10.01"), not(theInstance(bigDecimal)));
```

##### not

```java
assertThat(10, not(equalTo(5)));
assertThat(10, not(5));
```

##### nullValue

```java
assertThat(null, nullValue());
assertThat(null, nullValue(Integer.class));
```

##### notNullValue

```java
assertThat(new Object(), notNullValue());
assertThat(10, notNullValue(Integer.class));
```

##### describedAs

```java
assertThat("a b c", is(describedAs("a string that contains %0",
                                   containsString("d"),
                                   "letter d")));
// java.lang.AssertionError:
// Expected: is a string that contains "letter d"
// but: was "a b c"
```


### Comparables

##### comparesEqualTo

```java
assertThat(new BigDecimal("10.01"), comparesEqualTo(new BigDecimal("10.01")));
```

##### lessThan

```java
assertThat(new BigDecimal("10.01"), lessThan(new BigDecimal("10.02")));
```

##### lessThanOrEqualTo

```java
assertThat(new BigDecimal("10.01"), lessThanOrEqualTo(new BigDecimal("10.02")));
```

##### greaterThan

```java
assertThat(new BigDecimal("10.01"), greaterThan(new BigDecimal("9.02")));
```

##### greaterThanOrEqualTo

```java
assertThat(new BigDecimal("10.01"), greaterThanOrEqualTo(new BigDecimal("9.02")));
```


### Arrays

##### emptyArray

```java
assertThat(new Integer[]{}, emptyArray());
```

##### arrayWithSize

```java
assertThat(new Integer[] {1, 2, 3}, arrayWithSize(3));
assertThat(new Integer[] {1, 2, 3}, arrayWithSize(greaterThan(2)));
```

##### array

```java
assertThat(new Integer[] {1, 2, 3}, is(array(is(1), lessThan(3), greaterThan(2))));
```

##### hasItemInArray

```java
assertThat(new Integer[] {1, 2, 3}, hasItemInArray(2));
assertThat(new Integer[] {1, 2, 3}, hasItemInArray(lessThan(2)));
```

##### arrayContaining

```java
assertThat(new Integer[] {1, 2, 3}, arrayContaining(1, 2, 3));
assertThat(new Integer[] {1, 2, 3}, arrayContaining(is(1), lessThan(3), greaterThan(2)));
assertThat(new Integer[] {1, 2, 3}, arrayContaining(asList(is(1), lessThan(3), greaterThan(2))));
```

##### arrayContainingInAnyOrder

```java
assertThat(new Integer[] {1, 2, 3}, arrayContainingInAnyOrder(3, 1, 2));
assertThat(new Integer[] {1, 2, 3}, arrayContainingInAnyOrder(is(2), lessThan(2), greaterThan(2)));
assertThat(new Integer[] {1, 2, 3}, arrayContainingInAnyOrder(asList(is(2), lessThan(2), greaterThan(2))));
```


### Sequences

##### empty

```java
assertThat(emptyList(), empty());
```

##### emptyCollectionOf

```java
assertThat(new ArrayList<Integer>(), emptyCollectionOf(Integer.class));
```

##### emptyIterable

```java
assertThat(emptyList(), emptyIterable());
```

##### emptyIterableOf

```java
assertThat(new ArrayList<Integer>(), emptyIterableOf(Integer.class));
```

##### hasSize

```java
assertThat(asList(1, 2, 3), hasSize(3));
assertThat(asList(1, 2, 3), hasSize(equalTo(3)));
```

##### contains

```java
assertThat(asList(1, 2, 3), contains(1, 2, 3));
assertThat(asList(1, 2, 3), contains(is(1), lessThan(3), greaterThan(2)));
assertThat(asList(1, 2, 3), contains(asList(is(1), lessThan(3), greaterThan(2))));
assertThat(singletonList(1), contains(lessThan(5)));
```

##### containsInAnyOrder

```java
assertThat(asList(1, 2, 3), containsInAnyOrder(3, 1, 2));
assertThat(asList(1, 2, 3), containsInAnyOrder(is(2), lessThan(2), greaterThan(2)));
assertThat(asList(1, 2, 3), containsInAnyOrder(asList(is(2), lessThan(2), greaterThan(2))));
```

##### iterableWithSize

```java
assertThat(asList(1, 2), iterableWithSize(2));
assertThat(asList(1, 2), iterableWithSize(equalTo(2)));
```

##### isIn

```java
assertThat(2, isIn(asList(1, 2, 3)));
assertThat(2, isIn(new Integer[] {1, 2, 3}));
```

##### isOneOf

```java
assertThat(2, isOneOf(1, 2, 3));
```

##### everyItem

```java
assertThat(asList(1, 2, 3), everyItem(lessThan(4)));
```

##### hasItem

```java
assertThat(asList(1, 2, 3), hasItem(2));
assertThat(asList(1, 2, 3), hasItem(greaterThan(2)));
```

##### hasItems

```java
assertThat(asList(1, 2, 3), hasItems(2, 3));
assertThat(asList(1, 2, 3), hasItems(greaterThan(2), lessThan(2)));
```


### Maps

##### hasEntry

```java
final Map<String, Integer> map = new HashMap<>();
map.put("key1", 10);
map.put("key2", 20);

assertThat(map, hasEntry("key1", 10));
assertThat(map, hasEntry(is("key1"), greaterThan(5)));
```

##### hasKey

```java
final Map<String, Integer> map = new HashMap<>();
map.put("key1", 10);
map.put("key2", 20);

assertThat(map, hasKey("key1"));
assertThat(map, hasKey(startsWith("ke")));
```

##### hasValue

```java
final Map<String, Integer> map = new HashMap<>();
map.put("key1", 10);
map.put("key2", 20);

assertThat(map, hasValue(20));
assertThat(map, hasValue(lessThan(20)));
```


### Combiners

##### allOf

```java
assertThat(10, allOf(greaterThan(5), lessThan(20), not(equalTo(7))));
assertThat(10, allOf(asList(greaterThan(5), lessThan(20), not(equalTo(7)))));
```

##### anyOf

```java
assertThat(10, anyOf(equalTo(7), lessThan(20), not(equalTo(10))));
assertThat(10, anyOf(asList(equalTo(7), lessThan(20), not(equalTo(10)))));
```

##### both

```java
assertThat(10, both(greaterThan(5)).and(lessThan(20)));
```

##### either

```java
assertThat(10, either(greaterThan(50)).or(lessThan(20)));
```


### Strings

##### isEmptyString

```java
assertThat("", isEmptyString());
```

##### isEmptyOrNullString

```java
assertThat("", isEmptyOrNullString());
assertThat(null, isEmptyOrNullString());
```

##### startsWith

```java
assertThat("start middle end", startsWith("start"));
```

##### endsWith

```java
assertThat("start middle end", endsWith("end"));
```

##### containsString

```java
assertThat("start middle end", containsString("middle"));
```

##### equalToIgnoringCase

```java
assertThat("start middle end", equalToIgnoringCase("start MIDDLE end"));
```

##### equalToIgnoringWhiteSpace

```java
assertThat("start middle end", equalToIgnoringWhiteSpace("  start     middle end "));
```

##### stringContainsInOrder

```java
assertThat("start middle end", stringContainsInOrder(asList("start", "middle", "end")));
```

### Numbers

##### closeTo

```java
assertThat(10.01, closeTo(10, 0.02));
assertThat(new BigDecimal("10.01"), closeTo(new BigDecimal("10"), new BigDecimal("0.02")));
```