blob: c9d18948894b072f4bc620bec168a58c796125dd (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* Copyright 2001-2009 OFFIS, Tammo Freese
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.easymock;
/**
* Allows setting expectations for an associated expected invocation.
* Implementations of this interface are returned by
* {@link EasyMock#expect(Object)}, and by {@link EasyMock#expectLastCall()}.
*
* @param <T> type of what should be returned by this expected call
*/
public interface IExpectationSetters<T> {
/**
* Sets a return value that will be returned for the expected invocation.
*
* @param value
* the value to return.
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> andReturn(T value);
/**
* Sets a throwable that will be thrown for the expected invocation.
*
* @param throwable
* the throwable to throw.
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> andThrow(Throwable throwable);
/**
* Sets an object that will be used to calculate the answer for the expected
* invocation (either return a value, or throw an exception).
*
* @param answer
* the object used to answer the invocation.
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> andAnswer(IAnswer<? extends T> answer);
/**
* Sets an object implementing the same interface as the mock. The expected
* method call will be delegated to it with the actual arguments. The answer
* returned by this call will then be the answer returned by the mock
* (either return a value, or throw an exception).
*
* @param delegateTo
* the object the call is delegated to.
* @return the value returned by the delegated call.
*/
IExpectationSetters<T> andDelegateTo(Object delegateTo);
/**
* Sets a stub return value that will be returned for the expected
* invocation.
*
* @param value
* the value to return.
*/
void andStubReturn(T value);
/**
* Sets a stub throwable that will be thrown for the expected invocation.
*
* @param throwable
* the throwable to throw.
*/
void andStubThrow(Throwable throwable);
/**
* Sets a stub object that will be used to calculate the answer for the
* expected invocation (either return a value, or throw an exception).
*
* @param answer
* the object used to answer the invocation.
*/
void andStubAnswer(IAnswer<? extends T> answer);
/**
* Sets a stub object implementing the same interface as the mock. The
* expected method call will be delegated to it with the actual arguments.
* The answer returned by this call will then be the answer returned by the
* mock (either return a value, or throw an exception).
*
* @param delegateTo
* the object the call is delegated to.
*/
void andStubDelegateTo(Object delegateTo);
/**
* Sets stub behavior for the expected invocation (this is needed for void
* methods).
*/
void asStub();
/**
* Expect the last invocation <code>count</code> times.
*
* @param count
* the number of invocations expected.
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> times(int count);
/**
* Expect the last invocation between <code>min</code> and
* <code>max</code> times.
*
* @param min
* the minimum number of invocations expected.
* @param max
* the maximum number of invocations expected.
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> times(int min, int max);
/**
* Expect the last invocation once. This is default in EasyMock.
*
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> once();
/**
* Expect the last invocation at least once.
*
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> atLeastOnce();
/**
* Expect the last invocation any times.
*
* @return this object to allow method call chaining.
*/
IExpectationSetters<T> anyTimes();
}
|
