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 }