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.setset;
25  
26  import java.util.Collection;
27  import java.util.HashSet;
28  import java.util.Iterator;
29  import java.util.LinkedList;
30  
31  import org.jmock.Mock;
32  import org.jmock.MockObjectTestCase;
33  
34  import com.enspire.gemini.integration.model.setset.A;
35  import com.enspire.gemini.integration.model.setset.ABidirectionalDefault;
36  import com.enspire.gemini.integration.model.setset.AUnidirectional;
37  import com.enspire.gemini.integration.model.setset.B;
38  import com.enspire.gemini.integration.model.setset.BBidirectional;
39  import com.enspire.gemini.integration.model.setset.BUnidirectional;
40  
41  /***
42   * @author Dragan Djuric <dragand@dev.java.net>
43   *
44   */
45  public abstract class ABidirectionalAbstractTest extends MockObjectTestCase {
46  
47      private A testA;
48  
49      private Mock mockA;
50      private Mock mockB;
51      
52      protected abstract A createTestABidirectional();
53      
54      protected A createABidirectional() {
55          ABidirectionalDefault a = new ABidirectionalDefault();
56          a.setB(new HashSet());
57          return a;
58      }
59      
60      protected A createAUnidirectional() {
61          AUnidirectional a = new AUnidirectional();
62          a.setB(new HashSet());
63          return a;
64      }
65      
66      protected B createBBidirectional() {
67          BBidirectional b = new BBidirectional();
68          b.setA(new HashSet());
69          return b;
70      }
71      
72      protected B createBUnidirectional() {
73          BUnidirectional b = new BUnidirectional();
74          b.setA(new HashSet());
75          return b;
76      }
77  
78      /***
79       * @see TestCase#setUp()
80       */
81      protected void setUp() throws Exception {
82          super.setUp();
83          testA = createTestABidirectional();
84          mockA = new Mock(A.class);
85          mockB = new Mock(B.class);
86      }
87      
88      public void testBAddBidirectional() {
89          B bBidirectional = createBBidirectional();
90          testA.getB().add(bBidirectional);
91          assertTrue(testA.getB().contains(bBidirectional));
92          assertTrue(bBidirectional.getA().contains(testA));
93      }
94      
95      public void testBAddBUnidirectional() {
96          B bUnidirectional = createBUnidirectional();
97          testA.getB().add(bUnidirectional);
98          assertTrue(testA.getB().contains(bUnidirectional));
99          assertTrue(bUnidirectional.getA().contains(testA));
100     }
101     
102     public void testBAddAgain() {
103         B bBidirectional = createBBidirectional();
104         testA.getB().add(bBidirectional);
105         assertTrue(testA.getB().contains(bBidirectional));
106         assertTrue(bBidirectional.getA().contains(testA));
107         testA.getB().add(bBidirectional);
108         assertTrue(testA.getB().contains(bBidirectional));
109         assertTrue(bBidirectional.getA().contains(testA));
110         assertSame(1, testA.getB().size());
111         assertSame(1, bBidirectional.getA().size());
112     }
113         
114     public void testBRemove() {
115         B bBidirectional = createBBidirectional();
116         B bUnidirectional = createBUnidirectional();
117         testA.getB().add(bBidirectional);
118         assertTrue(testA.getB().contains(bBidirectional));
119         assertTrue(bBidirectional.getA().contains(testA));
120         testA.getB().add(bUnidirectional);
121         assertTrue(testA.getB().contains(bUnidirectional));
122         assertTrue(bUnidirectional.getA().contains(testA));
123         testA.getB().remove(bBidirectional);
124         assertFalse(testA.getB().contains(bBidirectional));
125         assertFalse(bBidirectional.getA().contains(testA));
126         testA.getB().remove(bUnidirectional);
127         assertFalse(testA.getB().contains(bUnidirectional));
128         assertFalse(testA.getB().contains(bUnidirectional));
129     }
130        
131     public void testBAddAll() {
132         B bBidirectional = createBBidirectional();
133         B bUnidirectional = createBUnidirectional();
134         Collection coll = new LinkedList();
135         coll.add(bBidirectional);
136         coll.add(bUnidirectional);
137         testA.getB().addAll(coll);
138         assertTrue(testA.getB().contains(bBidirectional));
139         assertTrue(bBidirectional.getA().contains(testA));
140         assertTrue(testA.getB().contains(bUnidirectional));
141         assertTrue(bUnidirectional.getA().contains(testA));
142         assertEquals(2, testA.getB().size());
143     }
144     
145     public void testBRemoveAll() {
146         B bBidirectional = createBBidirectional();
147         B bUnidirectional = createBUnidirectional();
148         Collection coll = new LinkedList();
149         coll.add(bBidirectional);
150         coll.add(bUnidirectional);
151         testA.getB().add(bBidirectional);
152         assertTrue(testA.getB().contains(bBidirectional));
153         assertTrue(bBidirectional.getA().contains(testA));
154         testA.getB().add(bUnidirectional);
155         assertTrue(testA.getB().contains(bUnidirectional));
156         assertTrue(bUnidirectional.getA().contains(testA));
157         testA.getB().removeAll(coll);
158         assertFalse(testA.getB().contains(bBidirectional));
159         assertFalse(bBidirectional.getA().contains(testA));
160         assertFalse(testA.getB().contains(bUnidirectional));
161         assertFalse(bUnidirectional.getA().contains(testA));
162     }
163     
164     
165     public void testBIteratorRemove() {
166         B bBidirectional = createBBidirectional();
167         testA.getB().add(bBidirectional);
168         assertTrue(testA.getB().contains(bBidirectional));
169         assertTrue(bBidirectional.getA().contains(testA));
170         Iterator it = testA.getB().iterator();
171         it.next();
172         it.remove();
173         assertFalse(testA.getB().contains(bBidirectional));
174         assertFalse(bBidirectional.getA().contains(testA));
175     }
176 
177 }