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.collectioncollection;
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.collectioncollection.A;
34  import com.enspire.gemini.integration.model.collectioncollection.ABidirectionalDefault;
35  import com.enspire.gemini.integration.model.collectioncollection.AUnidirectional;
36  import com.enspire.gemini.integration.model.collectioncollection.B;
37  import com.enspire.gemini.integration.model.collectioncollection.BBidirectional;
38  import com.enspire.gemini.integration.model.collectioncollection.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          BBidirectional b = new BBidirectional();
67          b.setA(new LinkedList());
68          return b;
69      }
70      
71      protected B createBUnidirectional() {
72          BUnidirectional b = new BUnidirectional();
73          b.setA(new LinkedList());
74          return b;
75      }
76  
77      /***
78       * @see TestCase#setUp()
79       */
80      protected void setUp() throws Exception {
81          super.setUp();
82          testA = createTestABidirectional();
83          mockA = new Mock(A.class);
84          mockB = new Mock(B.class);
85      }
86      
87      public void testBAddBidirectional() {
88          B bBidirectional = createBBidirectional();
89          testA.getB().add(bBidirectional);
90          assertTrue(testA.getB().contains(bBidirectional));
91          assertTrue(bBidirectional.getA().contains(testA));
92      }
93      
94      public void testBAddBUnidirectional() {
95          B bUnidirectional = createBUnidirectional();
96          testA.getB().add(bUnidirectional);
97          assertTrue(testA.getB().contains(bUnidirectional));
98          assertTrue(bUnidirectional.getA().contains(testA));
99      }
100     
101     public void testBAddAgain() {
102         B bBidirectional = createBBidirectional();
103         testA.getB().add(bBidirectional);
104         assertTrue(testA.getB().contains(bBidirectional));
105         assertTrue(bBidirectional.getA().contains(testA));
106         testA.getB().add(bBidirectional);
107         assertTrue(testA.getB().contains(bBidirectional));
108         assertTrue(bBidirectional.getA().contains(testA));
109         assertSame(1, testA.getB().size());
110         assertSame(1, bBidirectional.getA().size());
111     }
112         
113     public void testBRemove() {
114         B bBidirectional = createBBidirectional();
115         B bUnidirectional = createBUnidirectional();
116         testA.getB().add(bBidirectional);
117         assertTrue(testA.getB().contains(bBidirectional));
118         assertTrue(bBidirectional.getA().contains(testA));
119         testA.getB().add(bUnidirectional);
120         assertTrue(testA.getB().contains(bUnidirectional));
121         assertTrue(bUnidirectional.getA().contains(testA));
122         testA.getB().remove(bBidirectional);
123         assertFalse(testA.getB().contains(bBidirectional));
124         assertFalse(bBidirectional.getA().contains(testA));
125         testA.getB().remove(bUnidirectional);
126         assertFalse(testA.getB().contains(bUnidirectional));
127         assertFalse(testA.getB().contains(bUnidirectional));
128     }
129        
130     public void testBAddAll() {
131         B bBidirectional = createBBidirectional();
132         B bUnidirectional = createBUnidirectional();
133         Collection coll = new LinkedList();
134         coll.add(bBidirectional);
135         coll.add(bUnidirectional);
136         testA.getB().addAll(coll);
137         assertTrue(testA.getB().contains(bBidirectional));
138         assertTrue(bBidirectional.getA().contains(testA));
139         assertTrue(testA.getB().contains(bUnidirectional));
140         assertTrue(bUnidirectional.getA().contains(testA));
141         assertEquals(2, testA.getB().size());
142     }
143     
144     public void testBRemoveAll() {
145         B bBidirectional = createBBidirectional();
146         B bUnidirectional = createBUnidirectional();
147         Collection coll = new LinkedList();
148         coll.add(bBidirectional);
149         coll.add(bUnidirectional);
150         testA.getB().add(bBidirectional);
151         assertTrue(testA.getB().contains(bBidirectional));
152         assertTrue(bBidirectional.getA().contains(testA));
153         testA.getB().add(bUnidirectional);
154         assertTrue(testA.getB().contains(bUnidirectional));
155         assertTrue(bUnidirectional.getA().contains(testA));
156         testA.getB().removeAll(coll);
157         assertFalse(testA.getB().contains(bBidirectional));
158         assertFalse(bBidirectional.getA().contains(testA));
159         assertFalse(testA.getB().contains(bUnidirectional));
160         assertFalse(bUnidirectional.getA().contains(testA));
161     }
162     
163     
164     public void testBIteratorRemove() {
165         B bBidirectional = createBBidirectional();
166         testA.getB().add(bBidirectional);
167         assertTrue(testA.getB().contains(bBidirectional));
168         assertTrue(bBidirectional.getA().contains(testA));
169         Iterator it = testA.getB().iterator();
170         it.next();
171         it.remove();
172         assertFalse(testA.getB().contains(bBidirectional));
173         assertFalse(bBidirectional.getA().contains(testA));
174     }
175 
176 }