org.cthul.matchers.fluent8

Interface MapFluent<K,V,Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

All Superinterfaces:

org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>, org.cthul.matchers.fluent.FluentStep<Value,BaseFluent>, ObjectFluent<Value,BaseFluent,TheFluent,This>

All Known Subinterfaces:

MapFluent.AndChain<K,V,Value,TheFluent,This>, MapFluent.OrChain<K,V,Value,TheFluent,This>

All Known Implementing Classes:

MapFluent.Assert, MapFluent.Step

public interface MapFluent<K,V,Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>
extends org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value,BaseFluent,TheFluent,This>, ObjectFluent<Value,BaseFluent,TheFluent,This>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	MapFluent.AndChain<K,V,Value extends Map<K,V>,TheFluent,This extends MapFluent.AndChain<K,V,Value,TheFluent,This>>
static class	MapFluent.Assert<K,V,Value extends Map<K,V>>
static interface	MapFluent.OrChain<K,V,Value extends Map<K,V>,TheFluent,This extends MapFluent.OrChain<K,V,Value,TheFluent,This>>
static class	MapFluent.Step<K,V,Value extends Map<K,V>,TheFluent,This extends MapFluent.Step<K,V,Value,TheFluent,This>>

Method Summary

Modifier and Type	Method and Description
MapFluent.AndChain<K,V,Value,TheFluent,?>	all()
default ObjectFluent.Step<Boolean,TheFluent,?>	booleanValue(Object key)
MapFluent.AndChain<K,V,Value,TheFluent,?>	both()
MapFluent.AndChain<K,V,Value,TheFluent,?>	both(org.hamcrest.Matcher<? super Value> matcher)
default ObjectFluent.Step<Byte,TheFluent,?>	byteValue(Object key)
default DoubleFluent.Step<Double,TheFluent,?>	doubleValue(Object key)
MapFluent.OrChain<K,V,Value,TheFluent,?>	either()
MapFluent.OrChain<K,V,Value,TheFluent,?>	either(org.hamcrest.Matcher<? super Value> matcher)
default ComparableFluent.Step<Float,Float,TheFluent,?>	floatValue(Object key)
default TheFluent	hasEntry(K key, V value) Creates a matcher for Maps matching when the examined Map contains at least one entry whose key equals the specified key and whose value equals the specified value.
default TheFluent	hasKey(K key) Creates a matcher for Maps matching when the examined Map contains at least one key that is equal to the specified key.
default TheFluent	hasValue(V value) Creates a matcher for Maps matching when the examined Map contains at least one value that is equal to the specified value.
default IntegerFluent.Step<Integer,TheFluent,?>	intValue(Object key)
default CollectionFluent.Step<K,Set<K>,TheFluent,?>	keys()
default ComparableFluent.Step<Long,Long,TheFluent,?>	longValue(Object key)
default ObjectFluent.Step<Short,TheFluent,?>	shortValue(Object key)
default StringFluent.Step<String,TheFluent,?>	stringValue(Object key)
default ObjectFluent.Step<V,TheFluent,?>	value(Object key)
default CollectionFluent.Step<V,Collection<V>,TheFluent,?>	values()

Methods inherited from interface org.cthul.matchers.fluent8.ObjectFluent

get, get, hasToString, hasToString, isIn, isIn, isOneOf, notNullValue, nullValue, sameInstance, theInstance

Methods inherited from interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep

__, __, __, allOf, anyOf, as, as, equalTo, has, has, has, has, hasNot, hasNot, hasNot, hasNot, hasType, is, is, is, isA, isNot, isNot, isNot, noneOf, not, not, not, not, not

Method Detail

hasEntry

default TheFluent hasEntry(K key,
                           V value)

Creates a matcher for Maps matching when the examined Map contains at least one entry whose key equals the specified key and whose value equals the specified value.

For example:

assertThat(myMap, hasEntry("bar", "foo"))

Parameters:

key - the key that, in combination with the value, must be describe at least one entry

value - the value that, in combination with the key, must be describe at least one entry

Returns:

fluent

See Also:

IsMapContaining.hasEntry(java.lang.Object,java.lang.Object)

hasKey

default TheFluent hasKey(K key)

Creates a matcher for Maps matching when the examined Map contains at least one key that is equal to the specified key.

For example:

assertThat(myMap, hasKey("bar"))

Parameters:

key - the key that satisfying maps must contain

Returns:

fluent

See Also:

IsMapContaining.hasKey(java.lang.Object)

hasValue

default TheFluent hasValue(V value)

Creates a matcher for Maps matching when the examined Map contains at least one value that is equal to the specified value.

For example:

assertThat(myMap, hasValue("foo"))

Parameters:

value - the value that satisfying maps must contain

Returns:

fluent

See Also:

IsMapContaining.hasValue(java.lang.Object)

keys

default CollectionFluent.Step<K,Set<K>,TheFluent,?> keys()

Returns:

collection fluent step step

See Also:

MapAdapters.mapKeys()

values

default CollectionFluent.Step<V,Collection<V>,TheFluent,?> values()

Returns:

collection fluent step step

See Also:

MapAdapters.mapValues()

value

default ObjectFluent.Step<V,TheFluent,?> value(Object key)

Returns:

object fluent step step

See Also:

MapAdapters.value(java.lang.Object)

byteValue

default ObjectFluent.Step<Byte,TheFluent,?> byteValue(Object key)

Returns:

object fluent step step

See Also:

MapAdapters.byteValue(java.lang.Object)

booleanValue

default ObjectFluent.Step<Boolean,TheFluent,?> booleanValue(Object key)

Returns:

object fluent step step

See Also:

MapAdapters.booleanValue(java.lang.Object)

floatValue

default ComparableFluent.Step<Float,Float,TheFluent,?> floatValue(Object key)

Returns:

comparable fluent step step

See Also:

MapAdapters.floatValue(java.lang.Object)

doubleValue

default DoubleFluent.Step<Double,TheFluent,?> doubleValue(Object key)

Returns:

double fluent step step

See Also:

MapAdapters.doubleValue(java.lang.Object)

intValue

default IntegerFluent.Step<Integer,TheFluent,?> intValue(Object key)

Returns:

integer fluent step step

See Also:

MapAdapters.intValue(java.lang.Object)

longValue

default ComparableFluent.Step<Long,Long,TheFluent,?> longValue(Object key)

Returns:

comparable fluent step step

See Also:

MapAdapters.longValue(java.lang.Object)

shortValue

default ObjectFluent.Step<Short,TheFluent,?> shortValue(Object key)

Returns:

object fluent step step

See Also:

MapAdapters.shortValue(java.lang.Object)

stringValue

default StringFluent.Step<String,TheFluent,?> stringValue(Object key)

Returns:

string fluent step step

See Also:

MapAdapters.stringValue(java.lang.Object)

either

MapFluent.OrChain<K,V,Value,TheFluent,?> either()

Specified by:

either in interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

Specified by:

either in interface org.cthul.matchers.fluent.FluentStep<Value extends Map<K,V>,BaseFluent>

Specified by:

either in interface ObjectFluent<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

either

MapFluent.OrChain<K,V,Value,TheFluent,?> either(org.hamcrest.Matcher<? super Value> matcher)

Specified by:

either in interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

Specified by:

either in interface org.cthul.matchers.fluent.FluentStep<Value extends Map<K,V>,BaseFluent>

Specified by:

either in interface ObjectFluent<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

both

MapFluent.AndChain<K,V,Value,TheFluent,?> both()

Specified by:

both in interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

Specified by:

both in interface org.cthul.matchers.fluent.FluentStep<Value extends Map<K,V>,BaseFluent>

Specified by:

both in interface ObjectFluent<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

both

MapFluent.AndChain<K,V,Value,TheFluent,?> both(org.hamcrest.Matcher<? super Value> matcher)

Specified by:

both in interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

Specified by:

both in interface org.cthul.matchers.fluent.FluentStep<Value extends Map<K,V>,BaseFluent>

Specified by:

both in interface ObjectFluent<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

all

MapFluent.AndChain<K,V,Value,TheFluent,?> all()

Specified by:

all in interface org.cthul.matchers.fluent.ext.ExtensibleFluentStep<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>

Specified by:

all in interface org.cthul.matchers.fluent.FluentStep<Value extends Map<K,V>,BaseFluent>

Specified by:

all in interface ObjectFluent<Value extends Map<K,V>,BaseFluent,TheFluent extends BaseFluent,This extends MapFluent<K,V,Value,BaseFluent,TheFluent,This>>