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