VerificationsInOrder (JMockit Toolkit API)

java.lang.Object
- mockit.Verifications
- - mockit.VerificationsInOrder

public abstract class VerificationsInOrder
extends Verifications

Same as Verifications, but checking that invocations from code under test occurred in the same order as the verified expectations.

 // Exercise tested code.
 codeUnderTest.doSomething();

 // Now verify that the expected invocations occurred in a given order.
 new VerificationsInOrder() {{
    mock1.firstExpectedMethod(anyInt); minTimes = 1;
    mock2.secondExpectedMethod(1, "test"); maxTimes = 2;
    MockedClass.finalMethod(anyString);
 }};

See Also:: VerificationsInOrder(), VerificationsInOrder(int), unverifiedInvocations(), verifiedInvocations(Verifications), Tutorial

Field Summary

Fields
Modifier and Type	Field and Description
`protected CharSequence`	`$` An string assigned to this field will be used as a prefix for the error message shown for the current expectation if it's found to be violated.
`protected Object`	`any` Matches any `Object` reference received by a parameter of a reference type.
`protected Boolean`	`anyBoolean` Matches any `boolean` or `Boolean` value received by a parameter of one of these types.
`protected Byte`	`anyByte` Matches any `byte` or `Byte` value received by a parameter of one of these types.
`protected Character`	`anyChar` Matches any `char` or `Character` value received by a parameter of one of these types.
`protected Double`	`anyDouble` Matches any `double` or `Double` value received by a parameter of one of these types.
`protected Float`	`anyFloat` Matches any `float` or `Float` value received by a parameter of one of these types.
`protected Integer`	`anyInt` Matches any `int` or `Integer` value received by a parameter of one of these types.
`protected Long`	`anyLong` Matches any `long` or `Long` value received by a parameter of one of these type.
`protected Short`	`anyShort` Matches any `short` or `Short` value received by a parameter of one of these types.
`protected String`	`anyString` Matches any `String` value received by a parameter of this type.
`protected int`	`maxTimes` A non-negative value assigned to this field will be taken as the maximum number of times that invocations matching the current expectation should occur during replay.
`protected int`	`minTimes` A non-negative value assigned to this field will be taken as the minimum number of times that invocations matching the current expectation should occur during replay.
`protected int`	`times` A non-negative value assigned to this field will be taken as the exact number of times that invocations matching the current expectation should occur during replay.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`VerificationsInOrder()` Begins in-order verification on the mocked types/instances that were invoked while executing code under test.
`protected`	`VerificationsInOrder(int numberOfIterations)` Same as `VerificationsInOrder()`, but considering that such invocations occurred in a given number of iterations.

Method Summary

Methods
Modifier and Type	Method and Description
`protected <T> T`	`onInstance(T mockedInstance)` Calling this method causes the expectation recorded/verified on the given mocked instance to match only those invocations that occur on the same instance, at replay time.
`protected void`	`unverifiedInvocations()` Accounts for a sequence of invocations executed by code under test that are not explicitly verified in any verification block.
`protected void`	`verifiedInvocations(Verifications alreadyVerified)` Accounts for a sequence of invocations executed from code under test that have already been explicitly verified in a previous verification block.
`protected <T> T`	`with(Delegate<T> delegateObjectWithInvocationHandlerMethod)` Adds a custom argument matcher for a parameter in the current expectation.
`protected <T> T`	`with(Object argumentMatcher)` Adds a custom argument matcher for a parameter in the current expectation.
`protected <T> T`	`with(T argValue, Object argumentMatcher)` Adds a custom argument matcher for a parameter in the current expectation.
`protected <T> T`	`withAny(T arg)` Same as `withEqual(Object)`, but matching any argument value of the appropriate type.
`protected <T> T`	`withCapture(List<T> valueHolderForMultipleInvocations)` Captures the argument value passed into the associated expectation parameter, for each invocation that matches the expectation when the tested code is exercised.
`protected double`	`withEqual(double value, double delta)` Same as `withEqual(Object)`, but checking that a numeric invocation argument in the replay phase is sufficiently close to the given value.
`protected float`	`withEqual(float value, double delta)` Same as `withEqual(Object)`, but checking that a numeric invocation argument in the replay phase is sufficiently close to the given value.
`protected <T> T`	`withEqual(T arg)` When passed as argument for an expectation, creates a new matcher that will check if the given value is `equal` to the corresponding argument received by a matching invocation.
`protected <T> T`	`withInstanceLike(T object)` Same as `withEqual(Object)`, but checking that an invocation argument in the replay phase is an instance of the same class as the given object.
`protected <T> T`	`withInstanceOf(Class<T> argClass)` Same as `withEqual(Object)`, but checking that an invocation argument in the replay phase is an instance of the given class.
`protected <T extends CharSequence> T`	`withMatch(T regex)` Same as `withEqual(Object)`, but checking that a textual invocation argument in the replay phase matches the given `regular expression`.
`protected <T> T`	`withNotEqual(T arg)` Same as `withEqual(Object)`, but checking that the invocation argument in the replay phase is different from the given value.
`protected <T> T`	`withNotNull()` Same as `withEqual(Object)`, but checking that an invocation argument in the replay phase is not `null`.
`protected <T> T`	`withNull()` Same as `withEqual(Object)`, but checking that an invocation argument in the replay phase is `null`.
`protected <T extends CharSequence> T`	`withPrefix(T text)` Same as `withEqual(Object)`, but checking that a textual invocation argument in the replay phase starts with the given text.
`protected <T> T`	`withSameInstance(T object)` Same as `withEqual(Object)`, but checking that an invocation argument in the replay phase is the exact same instance as the one in the recorded/verified invocation.
`protected <T extends CharSequence> T`	`withSubstring(T text)` Same as `withEqual(Object)`, but checking that a textual invocation argument in the replay phase contains the given text as a substring.
`protected <T extends CharSequence> T`	`withSuffix(T text)` Same as `withEqual(Object)`, but checking that a textual invocation argument in the replay phase ends with the given text.

Methods inherited from class mockit.Verifications
withCapture

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

- Field Detail
  - any
```
protected final Object any
```
    Matches any Object reference received by a parameter of a reference type.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    The use of this field will usually require a cast to the specific parameter type. However, if there is any other parameter for which an argument matching constraint is specified, passing the null reference instead will have the same effect.
    When the parameter to be matched is a varargs parameter of element type V, the use of any should be cast to V[].
    In invocations to non-accessible methods or constructors (for example, with Deencapsulation.invoke(Object, String, Object...)), use withAny(T) instead.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyShort, anyString, Tutorial
  - anyString
```
protected final String anyString
```
    Matches any String value received by a parameter of this type.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyShort, any, Tutorial
  - anyLong
```
protected final Long anyLong
```
    Matches any long or Long value received by a parameter of one of these type.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyInt, anyShort, anyString, any, Tutorial
  - anyInt
```
protected final Integer anyInt
```
    Matches any int or Integer value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyLong, anyShort, anyString, any, Tutorial
  - anyShort
```
protected final Short anyShort
```
    Matches any short or Short value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyString, any, Tutorial
  - anyByte
```
protected final Byte anyByte
```
    Matches any byte or Byte value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyShort, anyString, any, Tutorial
  - anyBoolean
```
protected final Boolean anyBoolean
```
    Matches any boolean or Boolean value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyByte, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyShort, anyString, any, Tutorial
  - anyChar
```
protected final Character anyChar
```
    Matches any char or Character value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyDouble, anyFloat, anyInt, anyLong, anyShort, anyString, any, Tutorial
  - anyDouble
```
protected final Double anyDouble
```
    Matches any double or Double value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyFloat, anyInt, anyLong, anyShort, anyString, any, Tutorial
  - anyFloat
```
protected final Float anyFloat
```
    Matches any float or Float value received by a parameter of one of these types.
    This field can only be used as the argument value at the proper parameter position in a method/constructor invocation, when recording or verifying an expectation; it cannot be used anywhere else.
    
    See Also:
    anyBoolean, anyByte, anyChar, anyDouble, anyInt, anyLong, anyString, anyShort, any, Tutorial
  - times
```
protected int times
```
    A non-negative value assigned to this field will be taken as the exact number of times that invocations matching the current expectation should occur during replay.
    
    See Also:
    minTimes, maxTimes, Tutorial
  - minTimes
```
protected int minTimes
```
    A non-negative value assigned to this field will be taken as the minimum number of times that invocations matching the current expectation should occur during replay. Zero or a negative value implies there is no lower limit. The maximum number of times is automatically adjusted to allow any number of invocations.
    Both minTimes and maxTimes can be specified for the same expectation, as long as minTimes is assigned first.
    
    See Also:
    times, maxTimes, Tutorial
  - maxTimes
```
protected int maxTimes
```
    A non-negative value assigned to this field will be taken as the maximum number of times that invocations matching the current expectation should occur during replay. A negative value implies there is no upper limit.
    Both minTimes and maxTimes can be specified for the same expectation, as long as minTimes is assigned first.
    
    See Also:
    times, minTimes, Tutorial
  - $
```
protected CharSequence $
```
    An string assigned to this field will be used as a prefix for the error message shown for the current expectation if it's found to be violated.
    Inside an expectation/verification block, the assignment must follow the invocation which records/verifies the expectation; if there is no current expectation at the point the assignment appears, an IllegalStateException is thrown.
    Notice there are only two different ways in which an expectation can be violated: either an unexpected invocation occurs during replay, or a missing invocation is detected.
- Constructor Detail
  - VerificationsInOrder
```
protected VerificationsInOrder()
```
    Begins in-order verification on the mocked types/instances that were invoked while executing code under test.
    
    See Also:
    VerificationsInOrder(int)
  - VerificationsInOrder
```
protected VerificationsInOrder(int numberOfIterations)
```
    Same as VerificationsInOrder(), but considering that such invocations occurred in a given number of iterations.
    The effect of specifying a number of iterations larger than 1 (one) is equivalent to duplicating (like in "copy & paste") the whole sequence of verified expectations.
    
    Parameters:
    numberOfIterations - the positive number of iterations for the whole set of verified expectations
    See Also:
    Tutorial
- Method Detail
  - unverifiedInvocations
```
protected final void unverifiedInvocations()
```
    Accounts for a sequence of invocations executed by code under test that are not explicitly verified in any verification block. Such a "sequence" of invocations can include only a single invocation, or even be empty.
    Invocations matching an expectation recorded with a minimum invocation count - if any - are also included here, since their replay order could not be verified otherwise. This doesn't apply to strict expectations, though, since in that case the replay order must be as recorded.
    This method can be used to verify that one or more consecutive invocations occurred before others, and conversely to verify that one or more consecutive invocations occurred after others. The call to this method marks the position where the unverified invocations are expected to have occurred, relative to the explicitly verified ones.
    The exact sequence of unverified invocations accounted for by a particular call to this method depends on the position of the call relative to other verifications. Each grouping of explicit verifications will correspond to a sequence of consecutive (and verified) invocations from the code under test. So, if this method is called more than once from the same verification block, each call will account for a separate sequence of unverified invocations; each sequence will be verified to occur, as a whole, in the same order as it appears relative to those groupings of verified invocations.
    Notice that when this method is not used, the invocations from code under test need not be consecutive, but only have the same relative order as the verification calls.
    Finally, notice that you can combine an ordered verification block that verifies the position of some calls relative to others with a later unordered block which verifies some or all of those other invocations. The unordered block should not come before, however, since it would "consume" the verified invocations.
    
    See Also:
    verifiedInvocations(Verifications), Tutorial
  - verifiedInvocations
```
protected final void verifiedInvocations(Verifications alreadyVerified)
```
    Accounts for a sequence of invocations executed from code under test that have already been explicitly verified in a previous verification block.
    
    Parameters:
    alreadyVerified - an unordered verification block describing a group of already verified invocations
    
    Throws:
    
    IllegalArgumentException - if the given verifications are ordered
    See Also:
    unverifiedInvocations(), Tutorial
  - onInstance
```
protected final <T> T onInstance(T mockedInstance)
```
    Calling this method causes the expectation recorded/verified on the given mocked instance to match only those invocations that occur on the same instance, at replay time.
    By default, such instances can be different between the replay phase and the record or verify phase, even though the method or constructor invoked is the same, and the invocation arguments all match. The use of this method allows invocations to also be matched on the instance invoked.
    Typically, tests that need to match instance invocations on the mocked instances invoked will declare two or more mock fields and/or mock parameters of the exact same mocked type. These instances will then be passed to the code under test, which will invoke them during the replay phase. To avoid the need to explicitly call onInstance(Object) on each of these different instances of the same type, instance matching is implied (and automatically applied to all relevant invocations) whenever two or more mocked instances of the same type are in scope for a given test method. This property of the API makes the use of onInstance much less frequent than it might otherwise be.
    In most cases, an invocation to the given mocked instance will be made on the value returned by this method (ie, a chained invocation). However, in the situation where the tested method calls an instance method defined in a mocked super-class (possibly an overridden method called through the super keyword), it will be necessary to match on a different instance than the one used for recording invocations. To do so, this method should be given the desired instance to match, while the invocation to be recorded should be done on the available mocked instance, which must be a different one (otherwise a non-mocked method would get executed). This is valid only if the instance to be matched is assignable to the mocked type, and typically occurs when partially mocking a class hierarchy.
    
    Returns:
    the given mocked instance, allowing the invocation being recorded/verified to immediately follow the call to this method
    See Also:
    Tutorial
  - with
```
protected final <T> T with(T argValue,
         Object argumentMatcher)
```
    Adds a custom argument matcher for a parameter in the current expectation.
    The given matcher can be any existing Hamcrest matcher or a user provided one.
    Alternatively, it can be an instance of an invocation handler class. In this case, the non-private handler method must have a single parameter of a type capable of receiving the relevant argument values. The name of this handler method does not matter. Its return type, on the other hand, should either be boolean or void. In the first case, a return value of true will indicate a successful match for the actual invocation argument at replay time, while a return of false will cause the test to fail. In the case of a void return type, instead of returning a value the handler method should validate the actual invocation argument through a JUnit/TestNG assertion.
    For additional details, refer to withEqual(Object).
    
    Parameters:
    argValue - an arbitrary value of the proper type, necessary to provide a valid argument to the invocation parameter
    argumentMatcher - an instance of a class implementing the org.hamcrest.Matcher interface, or an instance of an invocation handler class containing an appropriate invocation handler method
    
    Returns:
    the given argValue
    See Also:
    with(Object), with(Delegate), Tutorial
  - with
```
protected final <T> T with(Object argumentMatcher)
```
    Adds a custom argument matcher for a parameter in the current expectation. This works just like with(Object, Object), but attempting to discover the argument type from the supplied Hamcrest argument matcher, when applicable.
    
    Parameters:
    argumentMatcher - an instance of a class implementing the org.hamcrest.Matcher interface, or an instance of an invocation handler class containing an appropriate invocation handler method
    
    Returns:
    the value recorded inside the given Hamcrest argument matcher, or null if there is no such value to be found
    See Also:
    with(Object, Object), with(Delegate), Tutorial
  - with
```
protected final <T> T with(Delegate<T> delegateObjectWithInvocationHandlerMethod)
```
    Adds a custom argument matcher for a parameter in the current expectation.
    The given delegate object is assumed to be an instance of an invocation handler class. The non-private handler method must have a single parameter capable of receiving the relevant argument values. The name of this handler method does not matter.
    The handler's return type, on the other hand, should be boolean or void. In the first case, a return value of true will indicate a successful match for the actual invocation argument at replay time, while a return of false will fail to match the invocation. In the case of a void return type, the handler method should validate the actual invocation argument through a JUnit/TestNG assertion.
    
    Parameters:
    delegateObjectWithInvocationHandlerMethod - an instance of a class with an appropriate invocation handler method
    
    Returns:
    the default primitive value corresponding to T if it's a primitive wrapper type, or null otherwise
    See Also:
    with(Object), with(Object, Object), Tutorial
  - withAny
```
protected final <T> T withAny(T arg)
```
    Same as withEqual(Object), but matching any argument value of the appropriate type.
    Consider using instead the "anyXyz" field appropriate to the parameter type: anyBoolean, anyByte, anyChar, anyDouble, anyFloat, anyInt, anyLong, anyShort, anyString, or any for other reference types.
    Note: when using Deencapsulation.invoke(Object, String, Object...), etc., it's valid to pass withAny(ParameterType.class) if an actual instance of the parameter type cannot be created.
    
    Parameters:
    arg - an arbitrary value which will match any argument value in the replay phase
    
    Returns:
    the input argument
    See Also:
    Tutorial
  - withCapture
```
protected final <T> T withCapture(List<T> valueHolderForMultipleInvocations)
```
    Captures the argument value passed into the associated expectation parameter, for each invocation that matches the expectation when the tested code is exercised. As each such value is captured, it gets added to the given list so that it can be inspected later.
    
    Parameters:
    valueHolderForMultipleInvocations - list into which the arguments received by matching invocations will be added
    
    Returns:
    the default value for type T
    See Also:
    Verifications.withCapture(), Tutorial
  - withEqual
```
protected final <T> T withEqual(T arg)
```
    When passed as argument for an expectation, creates a new matcher that will check if the given value is equal to the corresponding argument received by a matching invocation.
    The matcher is added to the end of the list of argument matchers for the invocation being recorded/verified. It cannot be reused for a different parameter.
    Usually, this particular method should not be used. Instead, simply pass the desired argument value directly, without any matcher. Only when specifying values for a varargs method it's useful, and even then only when some other argument matcher is also used.
    
    Parameters:
    arg - the expected argument value
    
    Returns:
    the given argument
    See Also:
    Tutorial
  - withEqual
```
protected final double withEqual(double value,
               double delta)
```
    Same as withEqual(Object), but checking that a numeric invocation argument in the replay phase is sufficiently close to the given value.
    
    Parameters:
    value - the center value for range comparison
    delta - the tolerance around the center value, for a range of [value - delta, value + delta]
    
    Returns:
    the given value
    See Also:
    Tutorial
  - withEqual
```
protected final float withEqual(float value,
              double delta)
```
    Same as withEqual(Object), but checking that a numeric invocation argument in the replay phase is sufficiently close to the given value.
    
    Parameters:
    value - the center value for range comparison
    delta - the tolerance around the center value, for a range of [value - delta, value + delta]
    
    Returns:
    the given value
    See Also:
    Tutorial
  - withInstanceLike
```
protected final <T> T withInstanceLike(T object)
```
    Same as withEqual(Object), but checking that an invocation argument in the replay phase is an instance of the same class as the given object.
    Equivalent to a withInstanceOf(object.getClass()) call, except that it returns object instead of null.
    
    Parameters:
    object - an instance of the desired class
    
    Returns:
    the given instance
    See Also:
    Tutorial
  - withInstanceOf
```
protected final <T> T withInstanceOf(Class<T> argClass)
```
    Same as withEqual(Object), but checking that an invocation argument in the replay phase is an instance of the given class.
    
    Parameters:
    argClass - the desired class
    
    Returns:
    always null; if you need a specific return value, use withInstanceLike(Object)
    See Also:
    Tutorial
  - withNotEqual
```
protected final <T> T withNotEqual(T arg)
```
    Same as withEqual(Object), but checking that the invocation argument in the replay phase is different from the given value.
    
    Parameters:
    arg - an arbitrary value, but different from the ones expected to occur during replay
    
    Returns:
    the given argument value
    See Also:
    Tutorial
  - withNull
```
protected final <T> T withNull()
```
    Same as withEqual(Object), but checking that an invocation argument in the replay phase is null.
    
    Returns:
    always null
    See Also:
    Tutorial
  - withNotNull
```
protected final <T> T withNotNull()
```
    Same as withEqual(Object), but checking that an invocation argument in the replay phase is not null.
    
    Returns:
    always null
    See Also:
    Tutorial
  - withSameInstance
```
protected final <T> T withSameInstance(T object)
```
    Same as withEqual(Object), but checking that an invocation argument in the replay phase is the exact same instance as the one in the recorded/verified invocation.
    
    Parameters:
    object - the desired instance
    
    Returns:
    the given object
    See Also:
    Tutorial
  - withSubstring
```
protected final <T extends CharSequence> T withSubstring(T text)
```
    Same as withEqual(Object), but checking that a textual invocation argument in the replay phase contains the given text as a substring.
    
    Parameters:
    text - an arbitrary non-null textual value
    
    Returns:
    the given text
    See Also:
    Tutorial
  - withPrefix
```
protected final <T extends CharSequence> T withPrefix(T text)
```
    Same as withEqual(Object), but checking that a textual invocation argument in the replay phase starts with the given text.
    
    Parameters:
    text - an arbitrary non-null textual value
    
    Returns:
    the given text
    See Also:
    Tutorial
  - withSuffix
```
protected final <T extends CharSequence> T withSuffix(T text)
```
    Same as withEqual(Object), but checking that a textual invocation argument in the replay phase ends with the given text.
    
    Parameters:
    text - an arbitrary non-null textual value
    
    Returns:
    the given text
    See Also:
    Tutorial
  - withMatch
```
protected final <T extends CharSequence> T withMatch(T regex)
```
    Same as withEqual(Object), but checking that a textual invocation argument in the replay phase matches the given regular expression.
    Note that this can be used for any string comparison, including case insensitive ones (with "(?i)" in the regex).
    
    Parameters:
    regex - an arbitrary (non-null) regular expression against which textual argument values will be matched
    
    Returns:
    the given regex
    See Also:
    Pattern.compile(String, int), Tutorial

Class VerificationsInOrder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class mockit.Verifications

Methods inherited from class java.lang.Object

Field Detail

any

anyString

anyLong

anyInt

anyShort

anyByte

anyBoolean

anyChar

anyDouble

anyFloat

times

minTimes

maxTimes

$

Constructor Detail

VerificationsInOrder

VerificationsInOrder

Method Detail

unverifiedInvocations

verifiedInvocations

onInstance

with

with

with

withAny

withCapture

withEqual

withEqual

withEqual

withInstanceLike

withInstanceOf

withNotEqual

withNull

withNotNull

withSameInstance

withSubstring

withPrefix

withSuffix

withMatch