Skip to content

Instantly share code, notes, and snippets.

@cedricwalter

cedricwalter/Hamcrest 1.3.md

Last active December 14, 2019 14:30
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save cedricwalter/ddd2cfbffd8ddb28d1ffffc20c0c41d4 to your computer and use it in GitHub Desktop.
Save cedricwalter/ddd2cfbffd8ddb28d1ffffc20c0c41d4 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Hamcrest 1.3.md

Hamcrest version: 1.3

Base matchers
Comparables
Arrays
Sequences
Maps
Combiners
Strings
Numbers

Base matchers

equalTo
assertThat(10, equalTo(10));
is
assertThat(10, is(10));
assertThat(10, is(greaterThan(5)));
isA
assertThat(10, isA(Integer.class));
typeCompatibleWith
assertThat(Integer.class, typeCompatibleWith(Number.class));
anything
assertThat(10, anything());
any
assertThat(10, any(Integer.class));
instanceOf
assertThat(10, instanceOf(Integer.class));
sameInstance
BigDecimal bigDecimal = new BigDecimal("10.01");
assertThat(new BigDecimal("10.01"), not(sameInstance(bigDecimal)));
theInstance
BigDecimal bigDecimal = new BigDecimal("10.01");
assertThat(new BigDecimal("10.01"), not(theInstance(bigDecimal)));
not
assertThat(10, not(equalTo(5)));
assertThat(10, not(5));
nullValue
assertThat(null, nullValue());
assertThat(null, nullValue(Integer.class));
notNullValue
assertThat(new Object(), notNullValue());
assertThat(10, notNullValue(Integer.class));
describedAs
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
assertThat(new BigDecimal("10.01"), comparesEqualTo(new BigDecimal("10.01")));
lessThan
assertThat(new BigDecimal("10.01"), lessThan(new BigDecimal("10.02")));
lessThanOrEqualTo
assertThat(new BigDecimal("10.01"), lessThanOrEqualTo(new BigDecimal("10.02")));
greaterThan
assertThat(new BigDecimal("10.01"), greaterThan(new BigDecimal("9.02")));
greaterThanOrEqualTo
assertThat(new BigDecimal("10.01"), greaterThanOrEqualTo(new BigDecimal("9.02")));

Arrays

emptyArray
assertThat(new Integer[]{}, emptyArray());
arrayWithSize
assertThat(new Integer[] {1, 2, 3}, arrayWithSize(3));
assertThat(new Integer[] {1, 2, 3}, arrayWithSize(greaterThan(2)));
array
assertThat(new Integer[] {1, 2, 3}, is(array(is(1), lessThan(3), greaterThan(2))));
hasItemInArray
assertThat(new Integer[] {1, 2, 3}, hasItemInArray(2));
assertThat(new Integer[] {1, 2, 3}, hasItemInArray(lessThan(2)));
arrayContaining
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
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
assertThat(emptyList(), empty());
emptyCollectionOf
assertThat(new ArrayList<Integer>(), emptyCollectionOf(Integer.class));
emptyIterable
assertThat(emptyList(), emptyIterable());
emptyIterableOf
assertThat(new ArrayList<Integer>(), emptyIterableOf(Integer.class));
hasSize
assertThat(asList(1, 2, 3), hasSize(3));
assertThat(asList(1, 2, 3), hasSize(equalTo(3)));
contains
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
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
assertThat(asList(1, 2), iterableWithSize(2));
assertThat(asList(1, 2), iterableWithSize(equalTo(2)));
isIn
assertThat(2, isIn(asList(1, 2, 3)));
assertThat(2, isIn(new Integer[] {1, 2, 3}));
isOneOf
assertThat(2, isOneOf(1, 2, 3));
everyItem
assertThat(asList(1, 2, 3), everyItem(lessThan(4)));
hasItem
assertThat(asList(1, 2, 3), hasItem(2));
assertThat(asList(1, 2, 3), hasItem(greaterThan(2)));
hasItems
assertThat(asList(1, 2, 3), hasItems(2, 3));
assertThat(asList(1, 2, 3), hasItems(greaterThan(2), lessThan(2)));

Maps

hasEntry
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
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
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
assertThat(10, allOf(greaterThan(5), lessThan(20), not(equalTo(7))));
assertThat(10, allOf(asList(greaterThan(5), lessThan(20), not(equalTo(7)))));
anyOf
assertThat(10, anyOf(equalTo(7), lessThan(20), not(equalTo(10))));
assertThat(10, anyOf(asList(equalTo(7), lessThan(20), not(equalTo(10)))));
both
assertThat(10, both(greaterThan(5)).and(lessThan(20)));
either
assertThat(10, either(greaterThan(50)).or(lessThan(20)));

Strings

isEmptyString
assertThat("", isEmptyString());
isEmptyOrNullString
assertThat("", isEmptyOrNullString());
assertThat(null, isEmptyOrNullString());
startsWith
assertThat("start middle end", startsWith("start"));
endsWith
assertThat("start middle end", endsWith("end"));
containsString
assertThat("start middle end", containsString("middle"));
equalToIgnoringCase
assertThat("start middle end", equalToIgnoringCase("start MIDDLE end"));
equalToIgnoringWhiteSpace
assertThat("start middle end", equalToIgnoringWhiteSpace("  start     middle end "));
stringContainsInOrder
assertThat("start middle end", stringContainsInOrder(asList("start", "middle", "end")));

Numbers

closeTo
assertThat(10.01, closeTo(10, 0.02));
assertThat(new BigDecimal("10.01"), closeTo(new BigDecimal("10"), new BigDecimal("0.02")));
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment