Clover Coverage Report - EasyMock 3.0
Coverage timestamp: sam. mai 8 2010 14:37:27 CEST
382   652   47   10,91
6   530   0,12   17,5
35     1,34  
2    
 
  UsageConstraintsTest       Line # 37 380 0% 45 12 97,1% 0.9713604
  UsageConstraintsTest.A       Line # 299 2 0% 2 0 100% 1.0
 
  (58)
 
1    /**
2    * Copyright 2001-2010 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10    * Unless required by applicable law or agreed to in writing, software
11    * distributed under the License is distributed on an "AS IS" BASIS,
12    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13    * See the License for the specific language governing permissions and
14    * limitations under the License.
15    */
16   
17    package org.easymock.tests2;
18   
19    import static org.easymock.EasyMock.*;
20    import static org.junit.Assert.*;
21   
22    import java.math.BigDecimal;
23    import java.util.Collections;
24    import java.util.Comparator;
25    import java.util.List;
26   
27    import org.easymock.EasyMock;
28    import org.easymock.LogicalOperator;
29    import org.easymock.internal.matchers.Equals;
30    import org.easymock.tests.IMethods;
31    import org.junit.Before;
32    import org.junit.Test;
33   
34    /**
35    * @author OFFIS, Tammo Freese
36    */
 
37    public class UsageConstraintsTest {
38    private IMethods mock;
39   
 
40  58 toggle @Before
41    public void setUp() {
42  58 mock = createMock(IMethods.class);
43    }
44   
 
45  2 toggle @Test
46    public void equalsMissing() {
47  2 mock.simpleMethodWithArgument(not(eq("asd")));
48  2 try {
49  2 mock.simpleMethodWithArgument(not("jkl"));
50  0 fail();
51    } catch (final IllegalStateException e) {
52  2 assertEquals("no matchers found.", e.getMessage());
53    }
54  2 try {
55  2 mock.simpleMethodWithArgument(or(eq("jkl"), "asd"));
56  0 fail();
57    } catch (final IllegalStateException e) {
58  2 assertEquals("2 matchers expected, 1 recorded.", e.getMessage());
59    }
60  2 try {
61  2 mock.threeArgumentMethod(1, "asd", eq("asd"));
62  0 fail();
63    } catch (final IllegalStateException e) {
64  2 assertEquals(
65    "3 matchers expected, 1 recorded.\n"
66    + "This exception usually occurs when matchers are mixed with raw values when recording a method:\n"
67    + "\tfoo(5, eq(6));\t// wrong\n"
68    + "You need to use no matcher at all or a matcher for every single param:\n"
69    + "\tfoo(eq(5), eq(6));\t// right\n" + "\tfoo(5, 6);\t// also right", e
70    .getMessage());
71    }
72   
73    }
74   
 
75  2 toggle @Test
76    public void differentConstraintsOnSameCall() {
77  2 mock.simpleMethodWithArgument((String) isNull());
78  2 mock.simpleMethodWithArgument((String) notNull());
79  2 replay(mock);
80  2 mock.simpleMethodWithArgument(null);
81  2 mock.simpleMethodWithArgument("2");
82    }
83   
 
84  2 toggle @Test
85    public void equals() {
86  2 assertEquals(new Equals(null), new Equals(null));
87  2 assertEquals(new Equals(new Integer(2)), new Equals(new Integer(2)));
88  2 assertFalse(new Equals(null).equals(null));
89  2 assertFalse(new Equals(null).equals("Test"));
90  2 try {
91  2 new Equals(null).hashCode();
92  0 fail();
93    } catch (final UnsupportedOperationException expected) {
94    }
95    }
96   
 
97  2 toggle @Test
98    public void constraints() {
99  2 expect(mock.threeArgumentMethod(and(geq(7), leq(10)), isA(String.class), contains("123"))).andReturn(
100    "456").atLeastOnce();
101  2 replay(mock);
102  2 boolean failed = false;
103  2 try {
104  2 mock.threeArgumentMethod(11, "", "01234");
105    } catch (final AssertionError expected) {
106  2 failed = true;
107    }
108  2 if (!failed) {
109  0 fail();
110    }
111  2 failed = false;
112  2 try {
113  2 mock.threeArgumentMethod(8, new Object(), "01234");
114    } catch (final AssertionError expected) {
115  2 failed = true;
116    }
117  2 if (!failed) {
118  0 fail();
119    }
120  2 failed = false;
121  2 try {
122  2 mock.threeArgumentMethod(8, "", "no match");
123    } catch (final AssertionError expected) {
124  2 failed = true;
125    }
126  2 if (!failed) {
127  0 fail();
128    }
129  2 assertEquals("456", mock.threeArgumentMethod(8, "", "01234"));
130  2 verify(mock);
131    }
132   
 
133  2 toggle @Test
134    public void andOverloaded() {
135  2 expect(mock.oneArg(and(eq(false), eq(false)))).andReturn("0");
136  2 expect(mock.oneArg(and(eq((byte) 1), eq((byte) 1)))).andReturn("1");
137  2 expect(mock.oneArg(and(eq('a'), eq('a')))).andReturn("2");
138  2 expect(mock.oneArg(and(eq((double) 1), eq((double) 1)))).andReturn("3");
139  2 expect(mock.oneArg(and(eq((float) 1), eq((float) 1)))).andReturn("4");
140  2 expect(mock.oneArg(and(eq(1), eq(1)))).andReturn("5");
141  2 expect(mock.oneArg(and(eq((long) 1), eq((long) 1)))).andReturn("6");
142  2 expect(mock.oneArg(and(eq((short) 1), eq((short) 1)))).andReturn("7");
143  2 expect(mock.oneArg(and(contains("a"), contains("d")))).andReturn("8");
144  2 expect(mock.oneArg(and(isA(Class.class), eq(Object.class)))).andReturn("9");
145  2 replay(mock);
146  2 assertEquals("9", mock.oneArg(Object.class));
147  2 assertEquals("0", mock.oneArg(false));
148  2 assertEquals("1", mock.oneArg((byte) 1));
149  2 assertEquals("2", mock.oneArg('a'));
150  2 assertEquals("3", mock.oneArg((double) 1));
151  2 assertEquals("7", mock.oneArg((short) 1));
152  2 assertEquals("8", mock.oneArg("abcde"));
153  2 assertEquals("4", mock.oneArg((float) 1));
154  2 assertEquals("5", mock.oneArg(1));
155  2 assertEquals("6", mock.oneArg((long) 1));
156  2 verify(mock);
157    }
158   
 
159  2 toggle @Test
160    public void orOverloaded() {
161  2 expect(mock.oneArg(or(eq(false), eq(true)))).andReturn("0");
162  2 expect(mock.oneArg(or(eq((byte) 1), eq((byte) 2)))).andReturn("1");
163  2 expect(mock.oneArg(or(eq((char) 1), eq((char) 2)))).andReturn("2");
164  2 expect(mock.oneArg(or(eq((double) 1), eq((double) 2)))).andReturn("3");
165  2 expect(mock.oneArg(or(eq((float) 1), eq((float) 2)))).andReturn("4");
166  2 expect(mock.oneArg(or(eq(1), eq(2)))).andReturn("5");
167  2 expect(mock.oneArg(or(eq((long) 1), eq((long) 2)))).andReturn("6");
168  2 expect(mock.oneArg(or(eq((short) 1), eq((short) 2)))).andReturn("7");
169  2 expect(mock.oneArg(or(eq("asd"), eq("jkl")))).andReturn("8");
170  2 expect(mock.oneArg(or(eq(this.getClass()), eq(Object.class)))).andReturn("9");
171  2 replay(mock);
172  2 assertEquals("9", mock.oneArg(Object.class));
173  2 assertEquals("0", mock.oneArg(true));
174  2 assertEquals("1", mock.oneArg((byte) 2));
175  2 assertEquals("2", mock.oneArg((char) 1));
176  2 assertEquals("3", mock.oneArg((double) 2));
177  2 assertEquals("7", mock.oneArg((short) 1));
178  2 assertEquals("8", mock.oneArg("jkl"));
179  2 assertEquals("4", mock.oneArg((float) 1));
180  2 assertEquals("5", mock.oneArg(2));
181  2 assertEquals("6", mock.oneArg((long) 1));
182  2 verify(mock);
183    }
184   
 
185  2 toggle @Test
186    public void notOverloaded() {
187  2 expect(mock.oneArg(not(eq(false)))).andReturn("0");
188  2 expect(mock.oneArg(not(eq((byte) 1)))).andReturn("1");
189  2 expect(mock.oneArg(not(eq('a')))).andReturn("2");
190  2 expect(mock.oneArg(not(eq((double) 1)))).andReturn("3");
191  2 expect(mock.oneArg(not(eq((float) 1)))).andReturn("4");
192  2 expect(mock.oneArg(not(eq(1)))).andReturn("5");
193  2 expect(mock.oneArg(not(eq((long) 1)))).andReturn("6");
194  2 expect(mock.oneArg(not(eq((short) 1)))).andReturn("7");
195  2 expect(mock.oneArg(not(contains("a")))).andReturn("8");
196  2 expect(mock.oneArg(not(isA(Class.class)))).andReturn("9");
197  2 replay(mock);
198  2 assertEquals("9", mock.oneArg(new Object()));
199  2 assertEquals("0", mock.oneArg(true));
200  2 assertEquals("1", mock.oneArg((byte) 2));
201  2 assertEquals("2", mock.oneArg('b'));
202  2 assertEquals("3", mock.oneArg((double) 2));
203  2 assertEquals("7", mock.oneArg((short) 2));
204  2 assertEquals("8", mock.oneArg("bcde"));
205  2 assertEquals("4", mock.oneArg((float) 2));
206  2 assertEquals("5", mock.oneArg(2));
207  2 assertEquals("6", mock.oneArg((long) 2));
208  2 verify(mock);
209    }
210   
 
211  2 toggle @Test
212    public void lessOrEqualOverloaded() {
213  2 expect(mock.oneArg(leq((byte) 1))).andReturn("1");
214  2 expect(mock.oneArg(leq((double) 1))).andReturn("3");
215  2 expect(mock.oneArg(leq((float) 1))).andReturn("4");
216  2 expect(mock.oneArg(leq(1))).andReturn("5");
217  2 expect(mock.oneArg(leq((long) 1))).andReturn("6");
218  2 expect(mock.oneArg(leq((short) 1))).andReturn("7");
219  2 expect(mock.oneArg(leq(new BigDecimal("1")))).andReturn("8");
220  2 replay(mock);
221  2 assertEquals("1", mock.oneArg((byte) 1));
222  2 assertEquals("3", mock.oneArg((double) 1));
223  2 assertEquals("7", mock.oneArg((short) 0));
224  2 assertEquals("4", mock.oneArg((float) -5));
225  2 assertEquals("5", mock.oneArg((int) -2));
226  2 assertEquals("6", mock.oneArg((long) -3));
227  2 assertEquals("8", mock.oneArg(new BigDecimal("0.5")));
228  2 verify(mock);
229    }
230   
 
231  2 toggle @Test
232    public void lessThanOverloaded() {
233  2 expect(mock.oneArg(lt((byte) 1))).andReturn("1");
234  2 expect(mock.oneArg(lt((double) 1))).andReturn("3");
235  2 expect(mock.oneArg(lt((float) 1))).andReturn("4");
236  2 expect(mock.oneArg(lt((int) 1))).andReturn("5");
237  2 expect(mock.oneArg(lt((long) 1))).andReturn("6");
238  2 expect(mock.oneArg(lt((short) 1))).andReturn("7");
239  2 expect(mock.oneArg(lt(new BigDecimal("1")))).andReturn("8");
240  2 replay(mock);
241  2 assertEquals("1", mock.oneArg((byte) 0));
242  2 assertEquals("3", mock.oneArg((double) 0));
243  2 assertEquals("7", mock.oneArg((short) 0));
244  2 assertEquals("4", mock.oneArg((float) -4));
245  2 assertEquals("5", mock.oneArg((int) -34));
246  2 assertEquals("6", mock.oneArg((long) -6));
247  2 assertEquals("8", mock.oneArg(new BigDecimal("0.5")));
248  2 verify(mock);
249    }
250   
 
251  2 toggle @Test
252    public void greaterOrEqualOverloaded() {
253  2 expect(mock.oneArg(geq((byte) 1))).andReturn("1");
254  2 expect(mock.oneArg(geq((double) 1))).andReturn("3");
255  2 expect(mock.oneArg(geq((float) 1))).andReturn("4");
256  2 expect(mock.oneArg(geq((int) 1))).andReturn("5");
257  2 expect(mock.oneArg(geq((long) 1))).andReturn("6");
258  2 expect(mock.oneArg(geq((short) 1))).andReturn("7");
259  2 expect(mock.oneArg(geq(new BigDecimal("1")))).andReturn("8");
260  2 replay(mock);
261  2 assertEquals("1", mock.oneArg((byte) 2));
262  2 assertEquals("3", mock.oneArg((double) 1));
263  2 assertEquals("7", mock.oneArg((short) 2));
264  2 assertEquals("4", mock.oneArg((float) 3));
265  2 assertEquals("5", mock.oneArg((int) 4));
266  2 assertEquals("6", mock.oneArg((long) 5));
267  2 assertEquals("8", mock.oneArg(new BigDecimal("1.5")));
268  2 verify(mock);
269    }
270   
 
271  2 toggle @Test
272    public void greaterThanOverloaded() {
273  2 expect(mock.oneArg(gt((byte) 1))).andReturn("1");
274  2 expect(mock.oneArg(gt((double) 1))).andReturn("3");
275  2 expect(mock.oneArg(gt((float) 1))).andReturn("4");
276  2 expect(mock.oneArg(gt((int) 1))).andReturn("5");
277  2 expect(mock.oneArg(gt((long) 1))).andReturn("6");
278  2 expect(mock.oneArg(gt((short) 1))).andReturn("7");
279  2 expect(mock.oneArg(gt(new BigDecimal("1")))).andReturn("8");
280  2 replay(mock);
281  2 assertEquals("1", mock.oneArg((byte) 2));
282  2 assertEquals("3", mock.oneArg((double) 2));
283  2 assertEquals("7", mock.oneArg((short) 2));
284  2 assertEquals("4", mock.oneArg((float) 3));
285  2 assertEquals("5", mock.oneArg((int) 2));
286  2 assertEquals("6", mock.oneArg((long) 5));
287  2 assertEquals("8", mock.oneArg(new BigDecimal("1.5")));
288  2 verify(mock);
289    }
290   
 
291  2 toggle @Test
292    public void cmpTo() {
293  2 expect(mock.oneArg(cmpEq(new BigDecimal("1.5")))).andReturn("0");
294  2 replay(mock);
295  2 assertEquals("0", mock.oneArg(new BigDecimal("1.50")));
296  2 verify(mock);
297    }
298   
 
299    public static class A {
300    private final int value;
301   
 
302  56 toggle public A(final int value) {
303  56 this.value = value;
304    }
305   
 
306  128 toggle public int getValue() {
307  128 return value;
308    }
309    }
310   
 
311  2 toggle @Test
312    public void compareWithComparator() {
313    // Undertype just to make sure the generic typing works
314  2 final Comparator<Object> comparator = new Comparator<Object>() {
 
315  64 toggle private int compare(final A a1, final A a2) {
316  64 return a1.getValue() - a2.getValue();
317    }
318   
 
319  64 toggle public int compare(final Object o1, final Object o2) {
320  64 return compare((A) o1, (A) o2);
321    }
322    };
323   
324    // Check my comparator works
325  2 assertTrue(comparator.compare(new A(1), new A(2)) < 0);
326  2 assertTrue(comparator.compare(new A(2), new A(1)) > 0);
327  2 assertTrue(comparator.compare(new A(1), new A(1)) == 0);
328   
329    // Now test EasyMock.cmp
330  2 checkOrder(mock, true);
331   
332  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.EQUAL))).andReturn("0");
333   
334  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.GREATER))).andReturn("1");
335   
336  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.GREATER_OR_EQUAL))).andReturn("2");
337  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.GREATER_OR_EQUAL))).andReturn("2");
338   
339  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.LESS_OR_EQUAL))).andReturn("3");
340  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.LESS_OR_EQUAL))).andReturn("3");
341   
342  2 expect(mock.oneArg(cmp(new A(5), comparator, LogicalOperator.LESS_THAN))).andReturn("4");
343   
344  2 replay(mock);
345   
346  2 checkItFails(null); // null is not comparable so always return false
347  2 try {
348  2 mock.oneArg("");
349  0 fail();
350    } catch (final AssertionError e) {
351    } // different type isn't either
352   
353  2 checkItFails(new A(4));
354  2 checkItFails(new A(6));
355  2 assertEquals("0", mock.oneArg(new A(5)));
356   
357  2 checkItFails(new A(4));
358  2 checkItFails(new A(5));
359  2 assertEquals("1", mock.oneArg(new A(6)));
360   
361  2 checkItFails(new A(4));
362  2 assertEquals("2", mock.oneArg(new A(6)));
363  2 assertEquals("2", mock.oneArg(new A(5)));
364   
365  2 checkItFails(new A(6));
366  2 assertEquals("3", mock.oneArg(new A(4)));
367  2 assertEquals("3", mock.oneArg(new A(5)));
368   
369  2 checkItFails(new A(5));
370  2 checkItFails(new A(6));
371  2 assertEquals("4", mock.oneArg(new A(4)));
372   
373  2 verify(mock);
374    }
375   
 
376  18 toggle private void checkItFails(final A a) {
377  18 try {
378  18 mock.oneArg(a);
379  0 fail();
380    } catch (final AssertionError e) {
381    }
382    }
383   
 
384  2 toggle @Test
385    public void any() {
386  2 expect(mock.oneArg(anyBoolean())).andReturn("0");
387  2 expect(mock.oneArg(anyByte())).andReturn("1");
388  2 expect(mock.oneArg(anyChar())).andReturn("2");
389  2 expect(mock.oneArg(anyDouble())).andReturn("3");
390  2 expect(mock.oneArg(anyFloat())).andReturn("4");
391  2 expect(mock.oneArg(anyInt())).andReturn("5");
392  2 expect(mock.oneArg(anyLong())).andReturn("6");
393  2 expect(mock.oneArg(anyShort())).andReturn("7");
394  2 expect(mock.oneArg((String) anyObject())).andReturn("8");
395  2 expect(mock.oneArg(anyObject(String.class))).andReturn("9");
396  2 expect(mock.oneArg((List<String>) EasyMock.<List<String>> anyObject())).andReturn("9"); // make sure there's no warning on the cast
397  2 replay(mock);
398  2 assertEquals("9", mock.oneArg(Collections.emptyList()));
399  2 assertEquals("0", mock.oneArg(true));
400  2 assertEquals("1", mock.oneArg((byte) 1));
401  2 assertEquals("2", mock.oneArg((char) 1));
402  2 assertEquals("3", mock.oneArg((double) 1));
403  2 assertEquals("7", mock.oneArg((short) 1));
404  2 assertEquals("8", mock.oneArg("Test"));
405  2 assertEquals("4", mock.oneArg((float) 1));
406  2 assertEquals("5", mock.oneArg((int) 1));
407  2 assertEquals("6", mock.oneArg((long) 1));
408  2 assertEquals("9", mock.oneArg("Other Test"));
409  2 verify(mock);
410    }
411   
 
412  2 toggle @Test
413    public void arrayEquals() {
414  2 expect(mock.oneArray(aryEq(new boolean[] { true }))).andReturn("0");
415  2 expect(mock.oneArray(aryEq(new byte[] { 1 }))).andReturn("1");
416  2 expect(mock.oneArray(aryEq(new char[] { 1 }))).andReturn("2");
417  2 expect(mock.oneArray(aryEq(new double[] { 1 }))).andReturn("3");
418  2 expect(mock.oneArray(aryEq(new float[] { 1 }))).andReturn("4");
419  2 expect(mock.oneArray(aryEq(new int[] { 1 }))).andReturn("5");
420  2 expect(mock.oneArray(aryEq(new long[] { 1 }))).andReturn("6");
421  2 expect(mock.oneArray(aryEq(new short[] { 1 }))).andReturn("7");
422  2 expect(mock.oneArray(aryEq(new String[] { "Test" }))).andReturn("8");
423  2 expect(mock.oneArray(aryEq(new Object[] { "Test" }))).andReturn("9");
424  2 replay(mock);
425  2 assertEquals("9", mock.oneArray(new Object[] { "Test" }));
426  2 assertEquals("0", mock.oneArray(new boolean[] { true }));
427  2 assertEquals("1", mock.oneArray(new byte[] { 1 }));
428  2 assertEquals("2", mock.oneArray(new char[] { 1 }));
429  2 assertEquals("3", mock.oneArray(new double[] { 1 }));
430  2 assertEquals("7", mock.oneArray(new short[] { 1 }));
431  2 assertEquals("8", mock.oneArray(new String[] { "Test" }));
432  2 assertEquals("4", mock.oneArray(new float[] { 1 }));
433  2 assertEquals("5", mock.oneArray(new int[] { 1 }));
434  2 assertEquals("6", mock.oneArray(new long[] { 1 }));
435  2 verify(mock);
436    }
437   
 
438  2 toggle @Test
439    public void greaterOrEqual() {
440  2 expect(mock.oneArg(geq(7))).andReturn("1").times(3);
441  2 expect(mock.oneArg(lt(7))).andStubReturn("2");
442   
443  2 replay(mock);
444   
445  2 assertEquals("1", mock.oneArg(7));
446  2 assertEquals("2", mock.oneArg(6));
447  2 assertEquals("1", mock.oneArg(8));
448  2 assertEquals("2", mock.oneArg(6));
449  2 assertEquals("1", mock.oneArg(9));
450   
451  2 verify(mock);
452    }
453   
 
454  2 toggle @Test
455    public void greaterThan() {
456  2 expect(mock.oneArg(gt(7))).andReturn("1").times(3);
457  2 expect(mock.oneArg(leq(7))).andStubReturn("2");
458   
459  2 replay(mock);
460   
461  2 assertEquals("1", mock.oneArg(8));
462  2 assertEquals("2", mock.oneArg(7));
463  2 assertEquals("1", mock.oneArg(9));
464  2 assertEquals("2", mock.oneArg(6));
465  2 assertEquals("1", mock.oneArg(10));
466   
467  2 verify(mock);
468    }
469   
 
470  2 toggle @Test
471    public void lessOrEqual() {
472  2 expect(mock.oneArg(leq(7))).andReturn("1").times(3);
473  2 expect(mock.oneArg(gt(7))).andStubReturn("2");
474   
475  2 replay(mock);
476   
477  2 assertEquals("1", mock.oneArg(7));
478  2 assertEquals("2", mock.oneArg(8));
479  2 assertEquals("1", mock.oneArg(6));
480  2 assertEquals("2", mock.oneArg(9));
481  2 assertEquals("1", mock.oneArg(5));
482   
483  2 verify(mock);
484    }
485   
 
486  2 toggle @Test
487    public void lessThan() {
488  2 expect(mock.oneArg(lt(7))).andReturn("1").times(3);
489  2 expect(mock.oneArg(geq(7))).andStubReturn("2");
490   
491  2 replay(mock);
492   
493  2 assertEquals("1", mock.oneArg(5));
494  2 assertEquals("2", mock.oneArg(7));
495  2 assertEquals("1", mock.oneArg(6));
496  2 assertEquals("2", mock.oneArg(8));
497  2 assertEquals("1", mock.oneArg(4));
498   
499  2 verify(mock);
500    }
501   
 
502  2 toggle @Test
503    public void testOr() {
504  2 expect(mock.oneArg(or(eq(7), eq(9)))).andReturn("1").atLeastOnce();
505  2 expect(mock.oneArg(anyInt())).andStubReturn("2");
506   
507  2 replay(mock);
508   
509  2 assertEquals("1", mock.oneArg(7));
510  2 assertEquals("1", mock.oneArg(9));
511  2 assertEquals("2", mock.oneArg(10));
512   
513  2 verify(mock);
514    }
515   
 
516  2 toggle @Test
517    public void testNull() {
518  2 expect(mock.threeArgumentMethod(eq(1), isNull(), eq(""))).andReturn("1");
519  2 expect(mock.threeArgumentMethod(eq(1), isNull(Object.class), eq(""))).andReturn("2");
520  2 expect(mock.threeArgumentMethod(eq(1), not(isNull()), eq(""))).andStubReturn("3");
521   
522  2 replay(mock);
523   
524  2 assertEquals("1", mock.threeArgumentMethod(1, null, ""));
525  2 assertEquals("2", mock.threeArgumentMethod(1, null, ""));
526  2 assertEquals("3", mock.threeArgumentMethod(1, new Object(), ""));
527   
528  2 verify(mock);
529    }
530   
 
531  2 toggle @Test
532    public void testNotNull() {
533  2 expect(mock.threeArgumentMethod(eq(1), notNull(), eq(""))).andReturn("1");
534  2 expect(mock.threeArgumentMethod(eq(1), notNull(Object.class), eq(""))).andReturn("2");
535  2 expect(mock.threeArgumentMethod(eq(1), not(notNull()), eq(""))).andStubReturn("3");
536   
537  2 replay(mock);
538   
539  2 assertEquals("1", mock.threeArgumentMethod(1, new Object(), ""));
540  2 assertEquals("2", mock.threeArgumentMethod(1, new Object(), ""));
541  2 assertEquals("3", mock.threeArgumentMethod(1, null, ""));
542   
543  2 verify(mock);
544    }
545   
 
546  2 toggle @Test
547    public void testFind() {
548  2 expect(mock.oneArg(find("[a-z]+\\d"))).andReturn("1").atLeastOnce();
549  2 expect(mock.oneArg(find("\\d\\d"))).andStubReturn("2");
550   
551  2 replay(mock);
552   
553  2 assertEquals("1", mock.oneArg("1ab12"));
554  2 assertEquals("2", mock.oneArg("312xx"));
555   
556  2 verify(mock);
557    }
558   
 
559  2 toggle @Test
560    public void testMatches() {
561  2 expect(mock.oneArg(matches("[a-z]+\\d\\d"))).andReturn("1").atLeastOnce();
562  2 expect(mock.oneArg(matches("\\d\\d\\d"))).andStubReturn("2");
563   
564  2 replay(mock);
565   
566  2 assertEquals("1", mock.oneArg("a12"));
567  2 assertEquals("2", mock.oneArg("131"));
568   
569  2 verify(mock);
570    }
571   
 
572  2 toggle @Test
573    public void testContains() {
574  2 expect(mock.oneArg(contains("ab"))).andReturn("1").atLeastOnce();
575  2 expect(mock.oneArg(contains("bc"))).andStubReturn("2");
576   
577  2 replay(mock);
578   
579  2 assertEquals("1", mock.oneArg("xabcx"));
580  2 assertEquals("2", mock.oneArg("xdbcx"));
581   
582  2 verify(mock);
583    }
584   
 
585  2 toggle @Test
586    public void testStartsWith() {
587  2 expect(mock.oneArg(startsWith("ab"))).andReturn("1").atLeastOnce();
588  2 expect(mock.oneArg(startsWith("bc"))).andStubReturn("2");
589   
590  2 replay(mock);
591   
592  2 assertEquals("1", mock.oneArg("abcx"));
593  2 assertEquals("2", mock.oneArg("bcxe"));
594   
595  2 verify(mock);
596    }
597   
 
598  2 toggle @Test
599    public void testEndsWith() {
600  2 expect(mock.oneArg(endsWith("ab"))).andReturn("1").atLeastOnce();
601  2 expect(mock.oneArg(endsWith("bc"))).andStubReturn("2");
602   
603  2 replay(mock);
604   
605  2 assertEquals("1", mock.oneArg("xab"));
606  2 assertEquals("2", mock.oneArg("xbc"));
607   
608  2 verify(mock);
609    }
610   
 
611  2 toggle @Test
612    public void equalsWithDelta() {
613  2 expect(mock.oneArg(eq(1.0D, 0.1D))).andReturn("1").atLeastOnce();
614  2 expect(mock.oneArg(eq(2.0D, 0.1D))).andStubReturn("2");
615  2 expect(mock.oneArg(eq(1.0F, 0.1F))).andReturn("3").atLeastOnce();
616  2 expect(mock.oneArg(eq(2.0F, 0.1F))).andStubReturn("4");
617  2 expect(mock.oneArg(eq(2.0F, 0.1F))).andStubReturn("4");
618   
619  2 replay(mock);
620   
621  2 assertEquals("1", mock.oneArg(1.0));
622  2 assertEquals("1", mock.oneArg(0.91));
623  2 assertEquals("1", mock.oneArg(1.09));
624  2 assertEquals("2", mock.oneArg(2.0));
625   
626  2 assertEquals("3", mock.oneArg(1.0F));
627  2 assertEquals("3", mock.oneArg(0.91F));
628  2 assertEquals("3", mock.oneArg(1.09F));
629  2 assertEquals("4", mock.oneArg(2.0F));
630   
631  2 verify(mock);
632    }
633   
 
634  2 toggle @Test
635    public void testSame() {
636  2 final Object one = new String("1243");
637  2 final Object two = new String("1243");
638   
639  2 assertNotSame(one, two);
640  2 assertEquals(one, two);
641   
642  2 expect(mock.oneArg(same(one))).andReturn("1").atLeastOnce();
643  2 expect(mock.oneArg(same(two))).andStubReturn("2");
644   
645  2 replay(mock);
646   
647  2 assertEquals("1", mock.oneArg(one));
648  2 assertEquals("2", mock.oneArg(two));
649   
650  2 verify(mock);
651    }
652    }