Skip to content

Instantly share code, notes, and snippets.

@cedricwalter
Last active December 14, 2019 14:30

Revisions

  1. cedricwalter renamed this gist Dec 14, 2019. 1 changed file with 0 additions and 0 deletions.
    File renamed without changes.
  2. cedricwalter created this gist Dec 14, 2019.
    464 changes: 464 additions & 0 deletions Hamcrest 1.3
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,464 @@
    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")));
    ```