java.lang.Object
- org.easymock.internal.ReplayState

All Implemented Interfaces:

java.io.Serializable, IMocksControlState
```
public class ReplayState
extends java.lang.Object
implements IMocksControlState, java.io.Serializable
```
A mock has two states, record and replay. This class handles the replay state where we return all recorded invocation for a method call on a mock.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field Description

private IMocksBehavior behavior

private java.util.concurrent.locks.ReentrantLock lock

private static long serialVersionUID

Constructor Summary

Constructors
Constructor Description

ReplayState(IMocksBehavior behavior)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`andAnswer(IAnswer<?> answer)`
`void`	`andDelegateTo(java.lang.Object answer)`
`void`	`andReturn(java.lang.Object value)`
`void`	`andStubAnswer(IAnswer<?> answer)`
`void`	`andStubDelegateTo(java.lang.Object delegateTo)`
`void`	`andStubReturn(java.lang.Object value)`
`void`	`andStubThrow(java.lang.Throwable throwable)`
`void`	`andThrow(java.lang.Throwable throwable)`
`void`	`andVoid()`
`void`	`assertRecordState()`
`void`	`asStub()`
`void`	`callback(java.lang.Runnable runnable)`
`void`	`checkIsUsedInOneThread(boolean shouldBeUsedInOneThread)`
`void`	`checkOrder(boolean value)`
`java.lang.Object`	`invoke(Invocation invocation)`
`private java.lang.Object`	`invokeInner(Invocation invocation)`
`void`	`makeThreadSafe(boolean threadSafe)`
`void`	`replay()`
`private void`	`throwWrappedIllegalStateException()`
`void`	`times(Range range)`
`void`	`verify()`
`void`	`verifyRecording()`
`void`	`verifyUnexpectedCalls()`

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

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - behavior
```
private final IMocksBehavior behavior
```
  - lock
```
private final java.util.concurrent.locks.ReentrantLock lock
```
- Constructor Detail
  - ReplayState
```
public ReplayState(IMocksBehavior behavior)
```
- Method Detail
  - invoke
```
public java.lang.Object invoke(Invocation invocation)
                        throws java.lang.Throwable
```
    Specified by:
    
    invoke in interface IMocksControlState
    
    Throws:
    
    java.lang.Throwable
  - invokeInner
```
private java.lang.Object invokeInner(Invocation invocation)
                              throws java.lang.Throwable
```
    Throws:
    
    java.lang.Throwable
  - verifyRecording
```
public void verifyRecording()
```
    Specified by:
    
    verifyRecording in interface IMocksControlState
  - verifyUnexpectedCalls
```
public void verifyUnexpectedCalls()
```
    Specified by:
    
    verifyUnexpectedCalls in interface IMocksControlState
  - verify
```
public void verify()
```
    Specified by:
    
    verify in interface IMocksControlState
  - replay
```
public void replay()
```
    Specified by:
    
    replay in interface IMocksControlState
  - callback
```
public void callback(java.lang.Runnable runnable)
```
  - checkOrder
```
public void checkOrder(boolean value)
```
    Specified by:
    
    checkOrder in interface IMocksControlState
  - makeThreadSafe
```
public void makeThreadSafe(boolean threadSafe)
```
    Specified by:
    
    makeThreadSafe in interface IMocksControlState
  - checkIsUsedInOneThread
```
public void checkIsUsedInOneThread(boolean shouldBeUsedInOneThread)
```
    Specified by:
    
    checkIsUsedInOneThread in interface IMocksControlState
  - andReturn
```
public void andReturn(java.lang.Object value)
```
    Specified by:
    
    andReturn in interface IMocksControlState
  - andThrow
```
public void andThrow(java.lang.Throwable throwable)
```
    Specified by:
    
    andThrow in interface IMocksControlState
  - andAnswer
```
public void andAnswer(IAnswer<?> answer)
```
    Specified by:
    
    andAnswer in interface IMocksControlState
  - andDelegateTo
```
public void andDelegateTo(java.lang.Object answer)
```
    Specified by:
    
    andDelegateTo in interface IMocksControlState
  - andVoid
```
public void andVoid()
```
    Specified by:
    
    andVoid in interface IMocksControlState
  - andStubReturn
```
public void andStubReturn(java.lang.Object value)
```
    Specified by:
    
    andStubReturn in interface IMocksControlState
  - andStubThrow
```
public void andStubThrow(java.lang.Throwable throwable)
```
    Specified by:
    
    andStubThrow in interface IMocksControlState
  - andStubAnswer
```
public void andStubAnswer(IAnswer<?> answer)
```
    Specified by:
    
    andStubAnswer in interface IMocksControlState
  - andStubDelegateTo
```
public void andStubDelegateTo(java.lang.Object delegateTo)
```
    Specified by:
    
    andStubDelegateTo in interface IMocksControlState
  - asStub
```
public void asStub()
```
    Specified by:
    
    asStub in interface IMocksControlState
  - times
```
public void times(Range range)
```
    Specified by:
    
    times in interface IMocksControlState
  - throwWrappedIllegalStateException
```
private void throwWrappedIllegalStateException()
```
  - assertRecordState
```
public void assertRecordState()
```
    Specified by:
    
    assertRecordState in interface IMocksControlState

Modifier and Type	Field	Description
`private IMocksBehavior`	`behavior`
`private java.util.concurrent.locks.ReentrantLock`	`lock`
`private static long`	`serialVersionUID`

Class ReplayState

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

behavior

lock

Constructor Detail

ReplayState

Method Detail

invoke

invokeInner

verifyRecording

verifyUnexpectedCalls

verify

replay

callback

checkOrder

makeThreadSafe

checkIsUsedInOneThread

andReturn

andThrow

andAnswer

andDelegateTo

andVoid

andStubReturn

andStubThrow

andStubAnswer

andStubDelegateTo

asStub

times

throwWrappedIllegalStateException

assertRecordState