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.LinkedList;
27  import java.util.Collection;
28  
29  import org.jmock.Mock;
30  import org.jmock.MockObjectTestCase;
31  
32  import com.enspire.gemini.integration.model.collectionsimple.ABidirectionalDefault;
33  import com.enspire.gemini.integration.model.collectionsimple.A;
34  import com.enspire.gemini.integration.model.collectionsimple.AUnidirectional;
35  import com.enspire.gemini.integration.model.collectionsimple.B;
36  import com.enspire.gemini.integration.model.collectionsimple.BBidirectional;
37  
38  /***
39   * @author Dragan Djuric <dragand@dev.java.net>
40   *
41   */
42  public class BBidirectionalTest extends MockObjectTestCase {
43  
44      private B testClass;
45  
46      private Mock mockA;
47      
48      protected A createABidirectional() {
49          ABidirectionalDefault a = new ABidirectionalDefault();
50          a.setB(new LinkedList());
51          return a;
52      }
53      
54      protected A createAUnidirectional() {
55          AUnidirectional a = new AUnidirectional();
56          a.setB(new LinkedList());
57          return a;
58      }
59      
60      protected B createBBidirectional() {
61          return new BBidirectional();
62      }
63  
64      /***
65       * @see TestCase#setUp()
66       */
67      protected void setUp() throws Exception {
68          super.setUp();
69          testClass = new BBidirectional();
70          mockA = new Mock(A.class);
71      }
72  
73      public void testASetOppositeBidirectional() {
74          A aBidirectional = createABidirectional();
75          testClass.setA(aBidirectional);
76          assertSame(aBidirectional, testClass.getA());
77          assertTrue(aBidirectional.getB().contains(testClass));
78      }
79      
80      public void testASetOppositeUnidirectional() {
81          A aUnidirectional = createAUnidirectional();
82          testClass.setA(aUnidirectional);
83          assertSame(aUnidirectional, testClass.getA());
84          assertTrue(aUnidirectional.getB().contains(testClass));
85      }
86      
87      public void testAUnset() {
88          A aBidirectional = createABidirectional();
89          testClass.setA(aBidirectional);
90          assertSame(aBidirectional, testClass.getA());
91          assertTrue(aBidirectional.getB().contains(testClass));
92          testClass.setA(null);
93          assertNull(testClass.getA());
94          assertFalse(aBidirectional.getB().contains(testClass));
95      }
96      
97      public void testASetAgain() {
98          A aBidirectional = createABidirectional();
99          testClass.setA(aBidirectional);
100         assertSame(aBidirectional, testClass.getA());
101         assertTrue(aBidirectional.getB().contains(testClass));
102         testClass.setA(aBidirectional);
103         assertSame(aBidirectional, testClass.getA());
104         assertTrue(aBidirectional.getB().contains(testClass));
105         assertSame(1, aBidirectional.getB().size());
106     }
107     
108     public void testAReplace() {
109         A aBidirectional = createABidirectional();
110         A aUnidirectional = createAUnidirectional();
111         testClass.setA(aBidirectional);
112         assertSame(aBidirectional, testClass.getA());
113         assertTrue(aBidirectional.getB().contains(testClass));
114         testClass.setA(aUnidirectional);
115         assertSame(aUnidirectional, testClass.getA());
116         assertTrue(aUnidirectional.getB().contains(testClass));
117         assertFalse(aBidirectional.getB().contains(testClass));
118     }
119     
120     public void testAReplaceConnected() {
121         A aBidirectional = createABidirectional();
122         A aBidirectional1 = createABidirectional();
123         testClass.setA(aBidirectional1);
124         assertSame(aBidirectional1, testClass.getA());
125         assertTrue(aBidirectional1.getB().contains(testClass));
126         testClass.setA(aBidirectional);
127         assertSame(aBidirectional, testClass.getA());
128         assertTrue(aBidirectional.getB().contains(testClass));
129         assertFalse(aBidirectional1.getB().contains(testClass));
130     }
131     
132     public void testAThrowsException() {
133         Mock mockCollection = new Mock(Collection.class);
134         Collection aBCollection = (Collection)mockCollection.proxy();
135         A a = (A)mockA.proxy();
136         A aBidirectional = createABidirectional();
137         testClass.setA(aBidirectional);
138         assertSame(aBidirectional, testClass.getA());
139         assertTrue(aBidirectional.getB().contains(testClass));
140         mockA.expects(once()).method("getB").withNoArguments().
141                 will(returnValue(aBCollection));
142         mockCollection.expects(once()).method("contains").with(same(testClass)).
143                 will(returnValue(false));
144         mockCollection.expects(once()).method("add").with(same(testClass)).
145                 will(throwException(new RuntimeException()));
146         try {
147             testClass.setA(a);
148             fail("RuntimeException should be thrown");
149         }catch(RuntimeException e) {
150             assertSame(aBidirectional, testClass.getA());
151             assertTrue(aBidirectional.getB().contains(testClass));
152         }
153     }
154 
155 }