KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tc > object > ClientObjectManagerTest


1 /*
2  * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright
3  * notice. All rights reserved.
4  */

5 package com.tc.object;
6
7 import EDU.oswego.cs.dl.util.concurrent.CyclicBarrier;
8
9 import com.tc.exception.ImplementMe;
10 import com.tc.net.protocol.tcm.TestChannelIDProvider;
11 import com.tc.object.bytecode.MockClassProvider;
12 import com.tc.object.cache.EvictionPolicy;
13 import com.tc.object.cache.NullCache;
14 import com.tc.object.config.DSOClientConfigHelper;
15 import com.tc.object.dna.api.DNA;
16 import com.tc.object.dna.api.DNACursor;
17 import com.tc.object.dna.api.DNAException;
18 import com.tc.object.idprovider.api.ObjectIDProvider;
19 import com.tc.object.loaders.ClassProvider;
20 import com.tc.object.logging.NullRuntimeLogger;
21 import com.tc.object.logging.RuntimeLogger;
22 import com.tc.object.tx.MockTransactionManager;
23 import com.tc.util.concurrent.ThreadUtil;
24
25 import java.util.HashSet JavaDoc;
26
27 public class ClientObjectManagerTest extends BaseDSOTestCase {
28   private ClientObjectManager mgr;
29   private TestRemoteObjectManager remoteObjectManager;
30   private DSOClientConfigHelper clientConfiguration;
31   private ObjectIDProvider idProvider;
32   private EvictionPolicy cache;
33   private RuntimeLogger runtimeLogger;
34   private ClassProvider classProvider;
35   private TCClassFactory classFactory;
36   private TestObjectFactory objectFactory;
37   private String JavaDoc rootName;
38   private Object JavaDoc object;
39   private ObjectID objectID;
40   private TCObject tcObject;
41
42   public void setUp() throws Exception JavaDoc {
43     remoteObjectManager = new TestRemoteObjectManager();
44     classProvider = new MockClassProvider();
45     clientConfiguration = configHelper();
46     classFactory = new TestClassFactory();
47     objectFactory = new TestObjectFactory();
48     cache = new NullCache();
49     runtimeLogger = new NullRuntimeLogger();
50
51     rootName = "myRoot";
52     object = new Object JavaDoc();
53     objectID = new ObjectID(1);
54     tcObject = new MockTCObject(objectID, object);
55     objectFactory.peerObject = object;
56     objectFactory.tcObject = tcObject;
57
58     mgr = new ClientObjectManagerImpl(remoteObjectManager, clientConfiguration, idProvider, cache, runtimeLogger,
59                                       new TestChannelIDProvider(), classProvider, classFactory, objectFactory,
60                                       new PortabilityImpl(clientConfiguration), null);
61     mgr.setTransactionManager(new MockTransactionManager());
62   }
63
64   /**
65    * Test to make sure that a root request that is blocked waiting for a server response doesn't block reconnect.
66    */

67   public void testLookupOrCreateRootDoesntBlockReconnect() throws Exception JavaDoc {
68     // prepare a successful object lookup
69
TestDNA dna = newEmptyDNA();
70     prepareObjectLookupResults(dna);
71
72     // prepare the lookup thread
73
CyclicBarrier barrier = new CyclicBarrier(1);
74     LookupRootAgent lookup1 = new LookupRootAgent(barrier, mgr, rootName, object);
75
76     // start the lookup
77
new Thread JavaDoc(lookup1).start();
78     // make sure the first caller has called down into the remote object manager
79
remoteObjectManager.retrieveRootIDCalls.take();
80     assertNull(remoteObjectManager.retrieveRootIDCalls.poll(0));
81
82     // now make sure that concurrent reconnect activity doesn't block
83
mgr.pause();
84     mgr.starting();
85     mgr.getAllObjectIDsAndClear(new HashSet JavaDoc());
86   }
87
88   /**
89    * Test to make sure that concurrent root requests only result in a single lookup to the server.
90    */

91   public void testLookupOrCreateRootConcurrently() throws Exception JavaDoc {
92
93     // prepare a successful object lookup
94
TestDNA dna = newEmptyDNA();
95     prepareObjectLookupResults(dna);
96
97     // prepare the lookup threads.
98
CyclicBarrier barrier = new CyclicBarrier(3);
99     LookupRootAgent lookup1 = new LookupRootAgent(barrier, mgr, rootName, object);
100     LookupRootAgent lookup2 = new LookupRootAgent(barrier, mgr, rootName, object);
101
102     // start the first lookup
103
new Thread JavaDoc(lookup1).start();
104     // make sure the first caller has called down into the remote object manager.
105
remoteObjectManager.retrieveRootIDCalls.take();
106     assertNull(remoteObjectManager.retrieveRootIDCalls.poll(0));
107
108     // now start another lookup and make sure that it doesn't call down into the remote object manager.
109
new Thread JavaDoc(lookup2).start();
110     ThreadUtil.reallySleep(5000);
111     assertNull(remoteObjectManager.retrieveRootIDCalls.poll(0));
112
113     // allow the first lookup to proceed.
114
remoteObjectManager.retrieveRootIDResults.put(objectID);
115
116     // make sure both lookups are complete.
117
barrier.barrier();
118
119     assertTrue(lookup1.success() && lookup2.success());
120
121     // They should both have the same result
122
assertEquals(lookup1, lookup2);
123
124     // but, the remote object manager retrieveRootID() should only have been called the first time.
125
assertNull(remoteObjectManager.retrieveRootIDCalls.poll(0));
126   }
127
128   private TestDNA newEmptyDNA() {
129     TestDNA dna = new TestDNA();
130     dna.type = Object JavaDoc.class;
131     dna.objectID = objectID;
132     dna.arraySize = 0;
133     return dna;
134   }
135
136   private void prepareObjectLookupResults(TestDNA dna) {
137     remoteObjectManager.retrieveResults.put(dna);
138   }
139
140   private static final class LookupRootAgent implements Runnable JavaDoc {
141     private final ClientObjectManager manager;
142     private final String JavaDoc rootName;
143     private final Object JavaDoc object;
144     public Object JavaDoc result;
145     public Throwable JavaDoc exception;
146     private final CyclicBarrier barrier;
147
148     private LookupRootAgent(CyclicBarrier barrier, ClientObjectManager manager, String JavaDoc rootName, Object JavaDoc object) {
149       this.barrier = barrier;
150       this.manager = manager;
151       this.rootName = rootName;
152       this.object = object;
153     }
154
155     public boolean success() {
156       return exception == null;
157     }
158
159     public void run() {
160       try {
161         result = manager.lookupOrCreateRoot(this.rootName, this.object);
162       } catch (Throwable JavaDoc t) {
163         t.printStackTrace();
164         this.exception = t;
165       } finally {
166         try {
167           barrier.barrier();
168         } catch (InterruptedException JavaDoc e) {
169           e.printStackTrace();
170         }
171       }
172     }
173
174     public boolean equals(Object JavaDoc o) {
175       if (o instanceof LookupRootAgent) {
176         LookupRootAgent cmp = (LookupRootAgent) o;
177         if (result == null) return cmp.result == null;
178         return result.equals(cmp.result);
179       } else return false;
180     }
181
182     public int hashCode() {
183       throw new RuntimeException JavaDoc("Don't ask me that.");
184     }
185
186   }
187
188   private static final class TestDNA implements DNA {
189
190     public Class JavaDoc type;
191     public ObjectID objectID;
192     public ObjectID parentObjectID = ObjectID.NULL_ID;
193     public int arraySize;
194
195     public long getVersion() {
196       throw new ImplementMe();
197     }
198
199     public boolean hasLength() {
200       throw new ImplementMe();
201     }
202
203     public int getArraySize() {
204       return this.arraySize;
205     }
206
207     public String JavaDoc getTypeName() {
208       return getClass().getName();
209     }
210
211     public ObjectID getObjectID() throws DNAException {
212       return objectID;
213     }
214
215     public ObjectID getParentObjectID() throws DNAException {
216       return parentObjectID;
217     }
218
219     public DNACursor getCursor() {
220       throw new ImplementMe();
221     }
222
223     public String JavaDoc getDefiningLoaderDescription() {
224       return "";
225     }
226
227     public boolean isDelta() {
228       return false;
229     }
230
231   }
232
233 }
234
Popular Tags