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.simplesimple;
25  
26  import org.jmock.Mock;
27  import org.jmock.MockObjectTestCase;
28  
29  import com.enspire.gemini.integration.model.simplesimple.A;
30  import com.enspire.gemini.integration.model.simplesimple.ABidirectional;
31  import com.enspire.gemini.integration.model.simplesimple.AUnidirectional;
32  import com.enspire.gemini.integration.model.simplesimple.B;
33  import com.enspire.gemini.integration.model.simplesimple.BBidirectional;
34  import com.enspire.gemini.integration.model.simplesimple.BUnidirectional;
35  
36  /***
37   * @author Dragan Djuric <dragand@dev.java.net>
38   *
39   */
40  public class ABidirectionalTest extends MockObjectTestCase {
41  
42      private A testClass;
43  
44      private Mock mockA;
45      private Mock mockB;
46      
47      protected A createABidirectional() {
48          return new ABidirectional();
49      }
50      
51      protected A createAUnidirectional() {
52          return new AUnidirectional();
53      }
54      
55      protected B createBBidirectional() {
56          return new BBidirectional();
57      }
58      
59      protected B createBUnidirectional() {
60          return new BUnidirectional();
61      }
62  
63      /***
64       * @see TestCase#setUp()
65       */
66      protected void setUp() throws Exception {
67          super.setUp();
68          testClass = new ABidirectional();
69          mockA = new Mock(A.class);
70          mockB = new Mock(B.class);
71      }
72  
73      public void testASetOppositeBidirectional() {
74          A aBidirectional = createABidirectional();
75          testClass.setA(aBidirectional);
76          assertSame(aBidirectional, testClass.getA());
77          assertSame(testClass, aBidirectional.getA());
78      }
79      
80      public void testASetOppositeUnidirectional() {
81          A aUnidirectional = createAUnidirectional();
82          testClass.setA(aUnidirectional);
83          assertSame(aUnidirectional, testClass.getA());
84          assertSame(testClass, aUnidirectional.getA());
85      }
86      
87      public void testAUnset() {
88          A aBidirectional = createABidirectional();
89          testClass.setA(aBidirectional);
90          assertSame(aBidirectional, testClass.getA());
91          assertSame(testClass, aBidirectional.getA());
92          testClass.setA(null);
93          assertNull(testClass.getA());
94          assertNull(aBidirectional.getA());
95      }
96      
97      public void testASetAgain() {
98          A aBidirectional = createABidirectional();
99          testClass.setA(aBidirectional);
100         assertSame(aBidirectional, testClass.getA());
101         assertSame(testClass, aBidirectional.getA());
102         testClass.setA(aBidirectional);
103         assertSame(aBidirectional, testClass.getA());
104         assertSame(testClass, aBidirectional.getA());
105     }
106     
107     public void testAReplace() {
108         A aBidirectional = createABidirectional();
109         A aUnidirectional = createAUnidirectional();
110         testClass.setA(aBidirectional);
111         assertSame(aBidirectional, testClass.getA());
112         assertSame(testClass, aBidirectional.getA());
113         testClass.setA(aUnidirectional);
114         assertSame(aUnidirectional, testClass.getA());
115         assertSame(testClass, aUnidirectional.getA());
116         assertNull(aBidirectional.getA());
117     }
118     
119     public void testAThrowsException() {
120         A a = (A)mockA.proxy();
121         A aBidirectional = createABidirectional();
122         testClass.setA(aBidirectional);
123         assertSame(aBidirectional, testClass.getA());
124         assertSame(testClass, aBidirectional.getA());
125         mockA.expects(once()).method("getA").withNoArguments().
126                 will(returnValue(null));
127         mockA.expects(once()).method("setA").with(same(testClass)).
128                 will(throwException(new RuntimeException()));
129         try {
130             testClass.setA(a);
131             fail("RuntimeException should be thrown");
132         }catch(RuntimeException e) {
133             assertSame(aBidirectional, testClass.getA());
134             assertSame(testClass, aBidirectional.getA());
135         }
136     }
137     
138     public void testBSetOppositeBidirectional() {
139         B bBidirectional = createBBidirectional();
140         testClass.setB(bBidirectional);
141         assertSame(bBidirectional, testClass.getB());
142         assertSame(testClass, bBidirectional.getA());
143     }
144     
145     public void testBSetOppositeUnidirectional() {
146         B bUnidirectional = createBUnidirectional();
147         testClass.setB(bUnidirectional);
148         assertSame(bUnidirectional, testClass.getB());
149         assertSame(testClass, bUnidirectional.getA());
150     }
151     
152     public void testBUnset() {
153         B bBidirectional = createBBidirectional();
154         testClass.setB(bBidirectional);
155         assertSame(bBidirectional, testClass.getB());
156         assertSame(testClass, bBidirectional.getA());
157         testClass.setB(null);
158         assertNull(testClass.getB());
159         assertNull(bBidirectional.getA());
160     }
161     
162     public void testBSetAgain() {
163         B bBidirectional = createBBidirectional();
164         testClass.setB(bBidirectional);
165         assertSame(bBidirectional, testClass.getB());
166         assertSame(testClass, bBidirectional.getA());
167         testClass.setB(bBidirectional);
168         assertSame(bBidirectional, testClass.getB());
169         assertSame(testClass, bBidirectional.getA());
170     }
171     
172     public void testBReplace() {
173         B bBidirectional = createBBidirectional();
174         B bUnidirectional = createBUnidirectional();
175         testClass.setB(bBidirectional);
176         assertSame(bBidirectional, testClass.getB());
177         assertSame(testClass, bBidirectional.getA());
178         testClass.setB(bUnidirectional);
179         assertSame(bUnidirectional, testClass.getB());
180         assertSame(testClass, bUnidirectional.getA());
181         assertNull(bBidirectional.getA());
182     }
183     
184     public void testBReplaceConnected() {
185         B bBidirectional = createBBidirectional();
186         B bBidirectional1 = createBBidirectional();
187         A aBidirectional = createABidirectional();
188         testClass.setB(bBidirectional);
189         assertSame(bBidirectional, testClass.getB());
190         assertSame(testClass, bBidirectional.getA());
191         aBidirectional.setB(bBidirectional1);
192         assertSame(bBidirectional1, aBidirectional.getB());
193         assertSame(aBidirectional, bBidirectional1.getA());
194         testClass.setB(bBidirectional1);
195         assertSame(bBidirectional1, testClass.getB());
196         assertSame(testClass, bBidirectional1.getA());
197         assertNull(bBidirectional.getA());
198         assertNull(aBidirectional.getB());
199     }
200     
201     public void testBThrowsException() {
202         B b = (B)mockB.proxy();
203         B bBidirectional = createBBidirectional();
204         testClass.setB(bBidirectional);
205         assertSame(bBidirectional, testClass.getB());
206         assertSame(testClass, bBidirectional.getA());
207         mockB.expects(once()).method("getA").withNoArguments().
208                 will(returnValue(null));
209         mockB.expects(once()).method("setA").with(same(testClass)).
210                 will(throwException(new RuntimeException()));
211         try {
212             testClass.setB(b);
213             fail("RuntimeException should be thrown");
214         }catch(RuntimeException e) {
215             assertSame(bBidirectional, testClass.getB());
216             assertSame(testClass, bBidirectional.getA());
217         }
218     }
219 
220 }