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