1   /*
2   * E-nspire Gemini.
3   * A Java and AspectJ based framework that enables transparent 
4   * bidirectional relationships between Plain Old Java Objects.
5   * 
6   * Copyright (C) 2005 Dragan Djuric
7   * 
8   * This program is free software; you can redistribute it and/or
9   * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  * 
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  * 
22  * Contact the author at dragand@dev.java.net
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 }