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.collectionsimple;
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.collectionsimple.A;
34  import com.enspire.gemini.integration.model.collectionsimple.ABidirectionalDefault;
35  import com.enspire.gemini.integration.model.collectionsimple.AUnidirectional;
36  import com.enspire.gemini.integration.model.collectionsimple.B;
37  import com.enspire.gemini.integration.model.collectionsimple.BBidirectional;
38  import com.enspire.gemini.integration.model.collectionsimple.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 testBRemove() {
141         B bBidirectional = createBBidirectional();
142         B bUnidirectional = createBUnidirectional();
143         testA.getB().add(bBidirectional);
144         assertTrue(testA.getB().contains(bBidirectional));
145         assertSame(testA, bBidirectional.getA());
146         testA.getB().add(bUnidirectional);
147         assertTrue(testA.getB().contains(bUnidirectional));
148         assertSame(testA, bUnidirectional.getA());
149         testA.getB().remove(bBidirectional);
150         assertFalse(testA.getB().contains(bBidirectional));
151         assertNull(bBidirectional.getA());
152         testA.getB().remove(bUnidirectional);
153         assertFalse(testA.getB().contains(bUnidirectional));
154         assertNull(bUnidirectional.getA());
155     }
156     
157     public void testBRemoveThrowsException() {
158         B b = (B)mockB.proxy();
159         B bBidirectional = createBBidirectional();
160         testA.getB().add(bBidirectional);
161         assertTrue(testA.getB().contains(bBidirectional));
162         assertSame(testA, bBidirectional.getA());
163         mockB.expects(once()).method("getA").withNoArguments().
164                 will(returnValue(null));
165         mockB.expects(once()).method("setA").with(same(testA));
166         testA.getB().add(b);
167         assertTrue(testA.getB().contains(b));
168         mockB.expects(once()).method("getA").withNoArguments().
169                 will(returnValue(testA));
170         mockB.expects(once()).method("setA").with(same(null)).
171                 will(throwException(new RuntimeException()));
172         try {
173             testA.getB().remove(b);
174             fail("RuntimeException should be thrown");
175         }catch(RuntimeException e) {
176             assertTrue(testA.getB().contains(bBidirectional));
177             assertSame(testA, bBidirectional.getA());
178             assertTrue(testA.getB().contains(b));
179         }
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 }