## org.jmock
Class Expectations

    java.lang.Object
      org.jmock.Expectations

All Implemented Interfaces:
  org.jmock.internal.ExpectationBuilder, ActionClause, ArgumentConstraintPhrases, CardinalityClause

    public class Expectations

extends Object
implements org.jmock.internal.ExpectationBuilder, CardinalityClause, ArgumentConstraintPhrases, ActionClause

Provides most of the syntax of jMock's "domain-specific language" API. The methods of this class don't make any sense on their own, so the Javadoc is rather sparse. Consult the documentation on the jMock website for information on how to use this API.

Author:
  nat

Constructor Summary
`Expectations()`

Method Summary
`static <any>` `a(Class<?> type)` Deprecated. use `aNonNull(java.lang.Class<T>)` or `any(java.lang.Class<T>)` until type inference actually works in a future version of Java
`MethodClause` `allowing(<any> mockObjectMatcher)`
`static <any>` `an(Class<?> type)` Deprecated. use `aNonNull(java.lang.Class<T>)` or `any(java.lang.Class<T>)` until type inference actually works in a future version of Java

`static

`<T> <any>`

`

`aNonNull(Class<T> type)`

`static

`<T> <any>`

`

`aNull(Class<T> type)`

`static

`<T> <any>`

`

`any(Class<T> type)`

`static

`<T> <any>`

`

`anything()`

`ReceiverClause` `atLeast(int count)`
`ReceiverClause` `atMost(int count)`
`ReceiverClause` `between(int minCount, int maxCount)`
`void` `buildExpectations(Action defaultAction, org.jmock.internal.ExpectationCollector collector)`
`protected org.jmock.internal.InvocationExpectationBuilder` `currentBuilder()`
`static Action` `doAll(Action... actions)`

`static

`<T> <any>`

`

`equal(T value)`

`ReceiverClause` `exactly(int count)`
`MethodClause` `ignoring(<any> mockObjectMatcher)`

`

`<T> T`

`

`ignoring(T mockObject)`

`void` `inSequence(Sequence sequence)`
`void` `inSequences(Sequence... sequences)`

`

`<T> T`

`

`never(T mockObject)`

`static Action` `onConsecutiveCalls(Action... actions)`

`

`<T> T`

`

`one(T mockObject)`
This will eventually be deprecated.

`

`<T> T`

`

`oneOf(T mockObject)`

`static Action` `returnEnumeration(Collection<?> collection)`

`static

`<T> Action`

`

`returnEnumeration(T... items)`

`static Action` `returnIterator(Collection<?> collection)`

`static

`<T> Action`

`

`returnIterator(T... items)`

`static Action` `returnValue(Object result)`

`static

`<T> <any>`

`

`same(T value)`

`void` `then(org.jmock.internal.State state)`
`static Action` `throwException(Throwable throwable)`
`void` `when(org.jmock.internal.StatePredicate predicate)`
`void` `will(Action action)`
`boolean` `with(<any> matcher)`
`byte` `with(<any> matcher)`
`short` `with(<any> matcher)`
`char` `with(<any> matcher)`
`int` `with(<any> matcher)`
`long` `with(<any> matcher)`
`float` `with(<any> matcher)`
`double` `with(<any> matcher)`

`

`<T> T`

`

`with(<any> matcher)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Expectations

    public Expectations()

Method Detail

### buildExpectations

    public void buildExpectations(Action defaultAction,
                                  org.jmock.internal.ExpectationCollector collector)

  Specified by:
    `buildExpectations` in interface `org.jmock.internal.ExpectationBuilder`

### currentBuilder

    protected org.jmock.internal.InvocationExpectationBuilder currentBuilder()

### exactly

    public ReceiverClause exactly(int count)

  Specified by:
    `exactly` in interface `CardinalityClause`

### oneOf

    public <T> T oneOf(T mockObject)

### one

    public <T> T one(T mockObject)

  This will eventually be deprecated. Use `oneOf` instead.

  Specified by:
    `one` in interface `CardinalityClause`

### atLeast

    public ReceiverClause atLeast(int count)

  Specified by:
    `atLeast` in interface `CardinalityClause`

### between

    public ReceiverClause between(int minCount,
                                  int maxCount)

  Specified by:
    `between` in interface `CardinalityClause`

### atMost

    public ReceiverClause atMost(int count)

  Specified by:
    `atMost` in interface `CardinalityClause`

### allowing

    public MethodClause allowing(<any> mockObjectMatcher)

  Specified by:
    `allowing` in interface `CardinalityClause`

### ignoring

    public <T> T ignoring(T mockObject)

  Specified by:
    `ignoring` in interface `CardinalityClause`

### ignoring

    public MethodClause ignoring(<any> mockObjectMatcher)

  Specified by:
    `ignoring` in interface `CardinalityClause`

### never

    public <T> T never(T mockObject)

  Specified by:
    `never` in interface `CardinalityClause`

### with

    public <T> T with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public boolean with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public byte with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public short with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public char with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public int with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public long with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public float with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### with

    public double with(<any> matcher)

  Specified by:
    `with` in interface `ArgumentConstraintPhrases`

### will

    public void will(Action action)

  Specified by:
    `will` in interface `ActionClause`

### equal

    public static <T> <any> equal(T value)

### same

    public static <T> <any> same(T value)

### any

    public static <T> <any> any(Class<T> type)

### anything

    public static <T> <any> anything()

### a

    @Deprecated
    public static <any> a(Class<?> type)

  Deprecated. use `aNonNull(java.lang.Class<T>)` or `any(java.lang.Class<T>)` until type inference actually works in a future version of Java

### an

    @Deprecated
    public static <any> an(Class<?> type)

  Deprecated. use `aNonNull(java.lang.Class<T>)` or `any(java.lang.Class<T>)` until type inference actually works in a future version of Java

### aNull

    public static <T> <any> aNull(Class<T> type)

### aNonNull

    public static <T> <any> aNonNull(Class<T> type)

### returnValue

    public static Action returnValue(Object result)

### throwException

    public static Action throwException(Throwable throwable)

### returnIterator

    public static Action returnIterator(Collection<?> collection)

### returnIterator

    public static <T> Action returnIterator(T... items)

### returnEnumeration

    public static Action returnEnumeration(Collection<?> collection)

### returnEnumeration

    public static <T> Action returnEnumeration(T... items)

### doAll

    public static Action doAll(Action... actions)

### onConsecutiveCalls

    public static Action onConsecutiveCalls(Action... actions)

### when

    public void when(org.jmock.internal.StatePredicate predicate)

### then

    public void then(org.jmock.internal.State state)

### inSequence

    public void inSequence(Sequence sequence)

### inSequences

    public void inSequences(Sequence... sequences)