Clover Coverage Report - EasyMock 3.0
Coverage timestamp: sam. mai 8 2010 14:37:27 CEST
52   180   23   2,26
0   134   0,44   23
23     1  
1    
 
  ConstraintsToStringTest       Line # 32 52 0% 23 0 100% 1.0
 
  (40)
 
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.junit.Assert.*;
20   
21    import java.util.ArrayList;
22    import java.util.List;
23   
24    import org.easymock.IArgumentMatcher;
25    import org.easymock.internal.matchers.*;
26    import org.junit.Before;
27    import org.junit.Test;
28   
29    /**
30    * @author OFFIS, Tammo Freese
31    */
 
32    public class ConstraintsToStringTest {
33    private StringBuffer buffer;
34   
 
35  40 toggle @Before
36    public void setup() {
37  40 buffer = new StringBuffer();
38    }
39   
 
40  2 toggle @Test
41    public void sameToStringWithString() {
42  2 new Same("X").appendTo(buffer);
43  2 assertEquals("same(\"X\")", buffer.toString());
44   
45    }
46   
 
47  2 toggle @Test
48    public void nullToString() {
49  2 Null.NULL.appendTo(buffer);
50  2 assertEquals("isNull()", buffer.toString());
51    }
52   
 
53  2 toggle @Test
54    public void notNullToString() {
55  2 NotNull.NOT_NULL.appendTo(buffer);
56  2 assertEquals("notNull()", buffer.toString());
57    }
58   
 
59  2 toggle @Test
60    public void anyToString() {
61  2 Any.ANY.appendTo(buffer);
62  2 assertEquals("<any>", buffer.toString());
63    }
64   
 
65  2 toggle @Test
66    public void sameToStringWithChar() {
67  2 new Same('x').appendTo(buffer);
68  2 assertEquals("same('x')", buffer.toString());
69    }
70   
 
71  2 toggle @Test
72    public void sameToStringWithObject() {
73  2 final Object o = new Object() {
 
74  2 toggle @Override
75    public String toString() {
76  2 return "X";
77    }
78    };
79  2 new Same(o).appendTo(buffer);
80  2 assertEquals("same(X)", buffer.toString());
81    }
82   
 
83  2 toggle @Test
84    public void equalsToStringWithString() {
85  2 new Equals("X").appendTo(buffer);
86  2 assertEquals("\"X\"", buffer.toString());
87   
88    }
89   
 
90  2 toggle @Test
91    public void equalsToStringWithChar() {
92  2 new Equals('x').appendTo(buffer);
93  2 assertEquals("'x'", buffer.toString());
94    }
95   
 
96  2 toggle @Test
97    public void equalsToStringWithObject() {
98  2 final Object o = new Object() {
 
99  2 toggle @Override
100    public String toString() {
101  2 return "X";
102    }
103    };
104  2 new Equals(o).appendTo(buffer);
105  2 assertEquals("X", buffer.toString());
106    }
107   
 
108  2 toggle @Test
109    public void equalsToStringWithArray() {
110  2 final String[] s = new String[] { "a", "b", null, "c" };
111  2 new Equals(s).appendTo(buffer);
112  2 assertEquals("[\"a\", \"b\", null, \"c\"]", buffer.toString());
113    }
114   
 
115  2 toggle @Test
116    public void orToString() {
117  2 final List<IArgumentMatcher> matchers = new ArrayList<IArgumentMatcher>();
118  2 matchers.add(new Equals(1));
119  2 matchers.add(new Equals(2));
120  2 new Or(matchers).appendTo(buffer);
121  2 assertEquals("or(1, 2)", buffer.toString());
122    }
123   
 
124  2 toggle @Test
125    public void notToString() {
126  2 new Not(new Equals(1)).appendTo(buffer);
127  2 assertEquals("not(1)", buffer.toString());
128    }
129   
 
130  2 toggle @Test
131    public void andToString() {
132  2 final List<IArgumentMatcher> matchers = new ArrayList<IArgumentMatcher>();
133  2 matchers.add(new Equals(1));
134  2 matchers.add(new Equals(2));
135  2 new And(matchers).appendTo(buffer);
136  2 assertEquals("and(1, 2)", buffer.toString());
137    }
138   
 
139  2 toggle @Test
140    public void startsWithToString() {
141  2 new StartsWith("AB").appendTo(buffer);
142  2 assertEquals("startsWith(\"AB\")", buffer.toString());
143    }
144   
 
145  2 toggle @Test
146    public void endsWithToString() {
147  2 new EndsWith("AB").appendTo(buffer);
148  2 assertEquals("endsWith(\"AB\")", buffer.toString());
149    }
150   
 
151  2 toggle @Test
152    public void containsToString() {
153  2 new Contains("AB").appendTo(buffer);
154  2 assertEquals("contains(\"AB\")", buffer.toString());
155    }
156   
 
157  2 toggle @Test
158    public void findToString() {
159  2 new Find("\\s+").appendTo(buffer);
160  2 assertEquals("find(\"\\\\s+\")", buffer.toString());
161    }
162   
 
163  2 toggle @Test
164    public void matchesToString() {
165  2 new Matches("\\s+").appendTo(buffer);
166  2 assertEquals("matches(\"\\\\s+\")", buffer.toString());
167    }
168   
 
169  2 toggle @Test
170    public void equalsWithDeltaToString() {
171  2 new EqualsWithDelta(2.1d, 0.2d).appendTo(buffer);
172  2 assertEquals("eq(2.1, 0.2)", buffer.toString());
173    }
174   
 
175  2 toggle @Test
176    public void arrayEqualsToString() {
177  2 new ArrayEquals(new Object[] { 1, "a", null }).appendTo(buffer);
178  2 assertEquals("[1, \"a\", null]", buffer.toString());
179    }
180    }