1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package com.enspire.gemini.integration.test.listsimple;
25
26 import java.util.Collection;
27 import java.util.Iterator;
28 import java.util.LinkedList;
29
30 import org.jmock.Mock;
31 import org.jmock.MockObjectTestCase;
32
33 import com.enspire.gemini.integration.model.listsimple.A;
34 import com.enspire.gemini.integration.model.listsimple.ABidirectionalDefault;
35 import com.enspire.gemini.integration.model.listsimple.AUnidirectional;
36 import com.enspire.gemini.integration.model.listsimple.B;
37 import com.enspire.gemini.integration.model.listsimple.BBidirectional;
38 import com.enspire.gemini.integration.model.listsimple.BUnidirectional;
39
40 /***
41 * @author Dragan Djuric <dragand@dev.java.net>
42 *
43 */
44 public abstract class ABidirectionalAbstractTest extends MockObjectTestCase {
45
46 private A testA;
47
48 private Mock mockA;
49 private Mock mockB;
50
51 protected abstract A createTestABidirectional();
52
53 protected A createABidirectional() {
54 ABidirectionalDefault a = new ABidirectionalDefault();
55 a.setB(new LinkedList());
56 return a;
57 }
58
59 protected A createAUnidirectional() {
60 AUnidirectional a = new AUnidirectional();
61 a.setB(new LinkedList());
62 return a;
63 }
64
65 protected B createBBidirectional() {
66 return new BBidirectional();
67 }
68
69 protected B createBUnidirectional() {
70 return new BUnidirectional();
71 }
72
73 /***
74 * @see TestCase#setUp()
75 */
76 protected void setUp() throws Exception {
77 super.setUp();
78 testA = createTestABidirectional();
79 mockA = new Mock(A.class);
80 mockB = new Mock(B.class);
81 }
82
83 public void testBAddBidirectional() {
84 B bBidirectional = createBBidirectional();
85 testA.getB().add(bBidirectional);
86 assertTrue(testA.getB().contains(bBidirectional));
87 assertSame(testA, bBidirectional.getA());
88 }
89
90 public void testBAddBUnidirectional() {
91 B bUnidirectional = createBUnidirectional();
92 testA.getB().add(bUnidirectional);
93 assertTrue(testA.getB().contains(bUnidirectional));
94 assertSame(testA, bUnidirectional.getA());
95 }
96
97 public void testBAddAgain() {
98 B bBidirectional = createBBidirectional();
99 testA.getB().add(bBidirectional);
100 assertTrue(testA.getB().contains(bBidirectional));
101 assertSame(testA, bBidirectional.getA());
102 testA.getB().add(bBidirectional);
103 assertTrue(testA.getB().contains(bBidirectional));
104 assertSame(testA, bBidirectional.getA());
105 assertSame(1, testA.getB().size());
106 }
107
108 public void testBAddConnected() {
109 B bBidirectional = createBBidirectional();
110 A aBidirectional = createABidirectional();
111 bBidirectional.setA(aBidirectional);
112 assertTrue(aBidirectional.getB().contains(bBidirectional));
113 assertSame(aBidirectional, bBidirectional.getA());
114 testA.getB().add(bBidirectional);
115 assertTrue(testA.getB().contains(bBidirectional));
116 assertSame(testA, bBidirectional.getA());
117 assertFalse(aBidirectional.getB().contains(bBidirectional));
118 }
119
120 public void testBAddThrowsException() {
121 B b = (B)mockB.proxy();
122 B bBidirectional = createBBidirectional();
123 testA.getB().add(bBidirectional);
124 assertTrue(testA.getB().contains(bBidirectional));
125 assertSame(testA, bBidirectional.getA());
126 mockB.expects(once()).method("getA").withNoArguments().
127 will(returnValue(null));
128 mockB.expects(once()).method("setA").with(same(testA)).
129 will(throwException(new RuntimeException()));
130 try {
131 testA.getB().add(b);
132 fail("RuntimeException should be thrown");
133 }catch(RuntimeException e) {
134 assertTrue(testA.getB().contains(bBidirectional));
135 assertSame(testA, bBidirectional.getA());
136 assertFalse(testA.getB().contains(b));
137 }
138 }
139
140 public void testBRemoveThrowsException() {
141 B b = (B)mockB.proxy();
142 B bBidirectional = createBBidirectional();
143 testA.getB().add(bBidirectional);
144 assertTrue(testA.getB().contains(bBidirectional));
145 assertSame(testA, bBidirectional.getA());
146 mockB.expects(once()).method("getA").withNoArguments().
147 will(returnValue(null));
148 mockB.expects(once()).method("setA").with(same(testA));
149 testA.getB().add(b);
150 assertTrue(testA.getB().contains(b));
151 mockB.expects(once()).method("getA").withNoArguments().
152 will(returnValue(testA));
153 mockB.expects(once()).method("setA").with(same(null)).
154 will(throwException(new RuntimeException()));
155 try {
156 testA.getB().remove(b);
157 fail("RuntimeException should be thrown");
158 }catch(RuntimeException e) {
159 assertTrue(testA.getB().contains(bBidirectional));
160 assertSame(testA, bBidirectional.getA());
161 assertTrue(testA.getB().contains(b));
162 }
163 }
164
165 public void testBRemove() {
166 B bBidirectional = createBBidirectional();
167 B bUnidirectional = createBUnidirectional();
168 testA.getB().add(bBidirectional);
169 assertTrue(testA.getB().contains(bBidirectional));
170 assertSame(testA, bBidirectional.getA());
171 testA.getB().add(bUnidirectional);
172 assertTrue(testA.getB().contains(bUnidirectional));
173 assertSame(testA, bUnidirectional.getA());
174 testA.getB().remove(bBidirectional);
175 assertFalse(testA.getB().contains(bBidirectional));
176 assertNull(bBidirectional.getA());
177 testA.getB().remove(bUnidirectional);
178 assertFalse(testA.getB().contains(bUnidirectional));
179 assertNull(bUnidirectional.getA());
180 }
181
182 public void testBAddAll() {
183 B bBidirectional = createBBidirectional();
184 B bUnidirectional = createBUnidirectional();
185 Collection coll = new LinkedList();
186 coll.add(bBidirectional);
187 coll.add(bUnidirectional);
188 testA.getB().addAll(coll);
189 assertTrue(testA.getB().contains(bBidirectional));
190 assertSame(testA, bBidirectional.getA());
191 assertTrue(testA.getB().contains(bUnidirectional));
192 assertSame(testA, bUnidirectional.getA());
193 assertEquals(2, testA.getB().size());
194 }
195
196 public void testBAddAllThrowsException() {
197 B b = (B)mockB.proxy();
198 B bBidirectional = createBBidirectional();
199 Collection coll = new LinkedList();
200 coll.add(bBidirectional);
201 coll.add(b);
202 mockB.expects(once()).method("getA").withNoArguments().
203 will(returnValue(null));
204 mockB.expects(once()).method("setA").with(same(testA)).
205 will(throwException(new RuntimeException()));
206 try {
207 testA.getB().addAll(coll);
208 fail("RuntimeException should be thrown");
209 }catch(RuntimeException e) {
210 assertFalse(testA.getB().contains(bBidirectional));
211 assertNull(bBidirectional.getA());
212 assertFalse(testA.getB().contains(b));
213 }
214 }
215
216 public void testBRemoveAll() {
217 B bBidirectional = createBBidirectional();
218 B bUnidirectional = createBUnidirectional();
219 Collection coll = new LinkedList();
220 coll.add(bBidirectional);
221 coll.add(bUnidirectional);
222 testA.getB().add(bBidirectional);
223 assertTrue(testA.getB().contains(bBidirectional));
224 assertSame(testA, bBidirectional.getA());
225 testA.getB().add(bUnidirectional);
226 assertTrue(testA.getB().contains(bUnidirectional));
227 assertSame(testA, bUnidirectional.getA());
228 testA.getB().removeAll(coll);
229 assertFalse(testA.getB().contains(bBidirectional));
230 assertNull(bBidirectional.getA());
231 assertFalse(testA.getB().contains(bUnidirectional));
232 assertNull(bUnidirectional.getA());
233 }
234
235 public void testBRemoveAllThrowsException() {
236 B b = (B)mockB.proxy();
237 B bBidirectional = createBBidirectional();
238 Collection coll = new LinkedList();
239 coll.add(bBidirectional);
240 coll.add(b);
241 mockB.expects(once()).method("getA").withNoArguments().
242 will(returnValue(null));
243 mockB.expects(once()).method("setA").with(same(testA));
244 testA.getB().addAll(coll);
245 mockB.expects(once()).method("getA").withNoArguments().
246 will(returnValue(testA));
247 mockB.expects(once()).method("setA").with(same(null)).
248 will(throwException(new RuntimeException()));
249 try {
250 testA.getB().removeAll(coll);
251 fail("RuntimeException should be thrown");
252 }catch(RuntimeException e) {
253 assertTrue(testA.getB().contains(bBidirectional));
254 assertEquals(testA, bBidirectional.getA());
255 assertTrue(testA.getB().contains(b));
256 }
257 }
258
259 public void testBIteratorRemove() {
260 B bBidirectional = createBBidirectional();
261 testA.getB().add(bBidirectional);
262 assertTrue(testA.getB().contains(bBidirectional));
263 assertSame(testA, bBidirectional.getA());
264 Iterator it = testA.getB().iterator();
265 it.next();
266 it.remove();
267 assertFalse(testA.getB().contains(bBidirectional));
268 assertNull(bBidirectional.getA());
269 }
270
271 public void testBSet() {
272 B bBidirectional = createBBidirectional();
273 B bBidirectional1 = createBBidirectional();
274 testA.getB().add(bBidirectional);
275 assertTrue(testA.getB().contains(bBidirectional));
276 assertSame(testA, bBidirectional.getA());
277 testA.getB().set(0, bBidirectional1);
278 assertTrue(testA.getB().contains(bBidirectional1));
279 assertSame(testA, bBidirectional1.getA());
280 assertFalse(testA.getB().contains(bBidirectional));
281 assertNull(bBidirectional.getA());
282 }
283
284 public void testBSetThrowsException() {
285 B b = (B)mockB.proxy();
286 B bBidirectional = createBBidirectional();
287 testA.getB().add(bBidirectional);
288 mockB.expects(once()).method("getA").withNoArguments().
289 will(returnValue(null));
290 mockB.expects(once()).method("setA").with(same(testA)).
291 will(throwException(new RuntimeException()));
292 try {
293 testA.getB().set(0, b);
294 fail("RuntimeException should be thrown");
295 }catch(RuntimeException e) {
296 assertTrue(testA.getB().contains(bBidirectional));
297 assertEquals(testA, bBidirectional.getA());
298 assertFalse(testA.getB().contains(b));
299 }
300 }
301
302 }