KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tc > objectserver > managedobject > ManagedObjectStateTest


1 /*
2  * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright notice. All rights reserved.
3  */
4 package com.tc.objectserver.managedobject;
5
6 import com.tc.object.ObjectID;
7 import com.tc.objectserver.core.api.TestDNACursor;
8 import com.tc.objectserver.managedobject.bytecode.ClassNotCompatableException;
9 import com.tc.objectserver.persistence.impl.InMemoryPersistor;
10
11 import java.util.Collection JavaDoc;
12 import java.util.HashMap JavaDoc;
13 import java.util.HashSet JavaDoc;
14 import java.util.Iterator JavaDoc;
15 import java.util.Map JavaDoc;
16 import java.util.Set JavaDoc;
17
18 import junit.framework.TestCase;
19
20 public class ManagedObjectStateTest extends TestCase {
21
22   private ObjectID objectID;
23   private ManagedObjectChangeListenerProvider listenerProvider;
24
25   public void setUp() throws Exception JavaDoc {
26     objectID = new ObjectID(2002);
27     listenerProvider = new NullManagedObjectChangeListenerProvider();
28   }
29
30   public void testPhysicalManagedObjectClassId() throws Exception JavaDoc {
31     String JavaDoc loaderDesc = "System.loader";
32
33     ManagedObjectStateFactory.disableSingleton(true);
34     ManagedObjectStateFactory.createInstance(listenerProvider, new InMemoryPersistor());
35
36     HashMap JavaDoc types = new HashMap JavaDoc();
37     types.put("field1", new ObjectID(1));
38     types.put("field2", new Boolean JavaDoc(true));
39     types.put("field3", new Character JavaDoc('c'));
40     types.put("field4", new Long JavaDoc(5));
41     types.put("field5", new Integer JavaDoc(15));
42     types.put("field6", new String JavaDoc("neoistheone"));
43     types.put("field7", new Short JavaDoc((short) 606));
44     types.put("field8", new Double JavaDoc(98.76d));
45     types.put("field9", new Float JavaDoc(8.8f));
46     // Not supported in 1.4
47 // types.put("field10", new StackTraceElement("classname", "methodname", "filename", 123));
48
49     TestDNACursor cursor = new TestDNACursor();
50     for (Iterator JavaDoc i = types.entrySet().iterator(); i.hasNext();) {
51       Map.Entry JavaDoc element = (Map.Entry JavaDoc) i.next();
52       cursor.addPhysicalAction((String JavaDoc) element.getKey(), element.getValue());
53     }
54
55     int numOfGeneratedClasses = 10000;
56     Map JavaDoc classNameToClassId = new HashMap JavaDoc();
57     Map JavaDoc classIdToClassName = new HashMap JavaDoc();
58
59     for (int i = 0; i < numOfGeneratedClasses; i++) {
60       String JavaDoc className = "com.xxx.SomeClassName" + i;
61       PhysicalManagedObjectState state = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
62           .createState(new ObjectID(1), ObjectID.NULL_ID, className, loaderDesc, cursor);
63       state.apply(objectID, cursor, new BackReferences());
64
65       int classId = state.getClassId();
66       assertTrue(classId != 0);
67       assertEquals(state.getClassName(), className);
68       assertEquals(state.getLoaderDescription(), loaderDesc);
69       
70       classNameToClassId.put(className, new Integer JavaDoc(classId));
71       assertNull(classIdToClassName.get(new Integer JavaDoc(classId)));
72       classIdToClassName.put(new Integer JavaDoc(classId), className);
73     }
74     
75     for (int i = 0; i < numOfGeneratedClasses; i++) {
76       String JavaDoc className = "com.xxx.SomeClassName" + i;
77       PhysicalManagedObjectState state = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
78           .createState(new ObjectID(1), ObjectID.NULL_ID, className, loaderDesc, cursor);
79       state.apply(objectID, cursor, new BackReferences());
80
81       int classId = state.getClassId();
82
83       Integer JavaDoc storedClassId = (Integer JavaDoc)classNameToClassId.get(className);
84       assertEquals(classId, storedClassId.intValue());
85       
86       String JavaDoc storedClassName = (String JavaDoc)classIdToClassName.get(new Integer JavaDoc(classId));
87       assertEquals(className, storedClassName);
88       
89     }
90   }
91
92   public void testPhysicalManagedObjectState() throws Exception JavaDoc {
93     String JavaDoc loaderDesc = "System.loader";
94
95     ManagedObjectStateFactory.disableSingleton(true);
96     ManagedObjectStateFactory.createInstance(listenerProvider, new InMemoryPersistor());
97
98     HashMap JavaDoc types = new HashMap JavaDoc();
99     types.put("field1", new ObjectID(1));
100     types.put("field2", new Boolean JavaDoc(true));
101     types.put("field3", new Character JavaDoc('c'));
102     types.put("field4", new Long JavaDoc(5));
103     types.put("field5", new Integer JavaDoc(15));
104     types.put("field6", new String JavaDoc("neoistheone"));
105     types.put("field7", new Short JavaDoc((short) 606));
106     types.put("field8", new Double JavaDoc(98.76d));
107     types.put("field9", new Float JavaDoc(8.8f));
108     // Not supported in 1.4
109 // types.put("field10", new StackTraceElement("classname", "methodname", "filename", 123));
110
111     TestDNACursor cursor = new TestDNACursor();
112     for (Iterator JavaDoc i = types.entrySet().iterator(); i.hasNext();) {
113       Map.Entry JavaDoc element = (Map.Entry JavaDoc) i.next();
114       cursor.addPhysicalAction((String JavaDoc) element.getKey(), element.getValue());
115     }
116
117     PhysicalManagedObjectState state = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
118         .createState(new ObjectID(1), ObjectID.NULL_ID, "com.xxx.SomeClassName", loaderDesc, cursor);
119     state.apply(objectID, cursor, new BackReferences());
120
121     assertTrue(state.getClassId() != 0);
122     assertEquals(state.getClassName(), "com.xxx.SomeClassName");
123     assertEquals(state.getLoaderDescription(), loaderDesc);
124
125     Collection JavaDoc references = state.getObjectReferences();
126     assertEquals(1, references.size());
127     assertEquals(new ObjectID(1), references.iterator().next());
128
129     Map JavaDoc values = state.addValues(new HashMap JavaDoc());
130     assertEquals(types.size(), values.size());
131     assertEquals(new ObjectID(1), values.get("field1"));
132
133     Boolean JavaDoc l2 = (Boolean JavaDoc) values.get("field2");
134     assertTrue(l2.booleanValue());
135     Character JavaDoc f3 = (Character JavaDoc) values.get("field3");
136     assertEquals(f3.charValue(), 'c');
137
138     System.err.println("values =" + values);
139     assertEquals(types, values);
140
141     cursor = new TestDNACursor();
142     cursor.addPhysicalAction("field1", new ObjectID(2));
143     cursor.addPhysicalAction("field2", new Boolean JavaDoc(false));
144     cursor.addPhysicalAction("field3", new Character JavaDoc('d'));
145
146     state.apply(objectID, cursor, new BackReferences());
147
148     references = state.getObjectReferences();
149     assertEquals(1, references.size());
150     assertEquals(new ObjectID(2), references.iterator().next());
151
152     values = state.addValues(new HashMap JavaDoc());
153     assertEquals(types.size(), values.size());
154     assertEquals(new ObjectID(2), values.get("field1"));
155
156     l2 = (Boolean JavaDoc) values.get("field2");
157     assertFalse(l2.booleanValue());
158     f3 = (Character JavaDoc) values.get("field3");
159     assertEquals(f3.charValue(), 'd');
160
161     assertEquals(ObjectID.NULL_ID, state.getParentID());
162   }
163
164   public void testPhysicalMOStateClassInCompatibility() throws Exception JavaDoc {
165     String JavaDoc loaderDesc = "System.loader";
166
167     InMemoryPersistor persistor = new InMemoryPersistor();
168     ManagedObjectStateFactory.disableSingleton(true);
169     ManagedObjectStateFactory.createInstance(listenerProvider, persistor);
170
171     TestDNACursor cursor = new TestDNACursor();
172     cursor.addPhysicalAction("field1", new ObjectID(1));
173     cursor.addPhysicalAction("field2", new Long JavaDoc(11));
174     cursor.addPhysicalAction("field3", new String JavaDoc("neoistheone"));
175
176     PhysicalManagedObjectState state = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
177         .createState(objectID, ObjectID.NULL_ID, "com.xxx.SomeClassName", loaderDesc, cursor);
178     state.apply(objectID, cursor, new BackReferences());
179
180     assertTrue(state.getClassId() != 0);
181     assertEquals(state.getClassName(), "com.xxx.SomeClassName");
182     assertEquals(state.getLoaderDescription(), loaderDesc);
183
184     Collection JavaDoc references = state.getObjectReferences();
185     assertEquals(1, references.size());
186     assertEquals(new ObjectID(1), references.iterator().next());
187
188     Map JavaDoc values = state.addValues(new HashMap JavaDoc());
189     assertEquals(3, values.size());
190     assertEquals(new ObjectID(1), values.get("field1"));
191
192     Long JavaDoc l2 = (Long JavaDoc) values.get("field2");
193     assertEquals(11, l2.longValue());
194     String JavaDoc f3 = (String JavaDoc) values.get("field3");
195     assertEquals(f3, "neoistheone");
196
197     cursor = new TestDNACursor();
198     cursor.addPhysicalAction("field1", new ObjectID(2));
199     // Newly added fields
200 cursor.addPhysicalAction("field4", new Boolean JavaDoc(false));
201     cursor.addPhysicalAction("field5", new ObjectID(22));
202
203     try {
204       state.apply(objectID, cursor, new BackReferences());
205       assertTrue(false);
206     } catch (ClassNotCompatableException cfe) {
207       // expected
208 }
209
210     // recreate the state object
211 PhysicalManagedObjectState state1 = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
212         .recreateState(objectID, ObjectID.NULL_ID, "com.xxx.SomeClassName", loaderDesc, cursor, state);
213     state1.apply(objectID, cursor, new BackReferences());
214
215     assertTrue(state1.getClassId() != state.getClassId());
216     assertEquals(state1.getClassName(), "com.xxx.SomeClassName");
217     assertEquals(state1.getLoaderDescription(), loaderDesc);
218
219     references = state1.getObjectReferences();
220     assertEquals(2, references.size());
221     Set JavaDoc expectedRefs = new HashSet JavaDoc();
222     expectedRefs.add(new ObjectID(2));
223     expectedRefs.add(new ObjectID(22));
224
225     values = state1.addValues(new HashMap JavaDoc());
226     assertEquals(new ObjectID(2), values.get("field1"));
227     l2 = (Long JavaDoc) values.get("field2");
228     assertEquals(11, l2.longValue());
229     f3 = (String JavaDoc) values.get("field3");
230     assertEquals(f3, "neoistheone");
231     Boolean JavaDoc f4 = (Boolean JavaDoc) values.get("field4");
232     assertEquals(f4, new Boolean JavaDoc(false));
233     assertEquals(new ObjectID(22), values.get("field5"));
234
235     // Now try applying yet another new field on the old object
236 TestDNACursor cursor2 = new TestDNACursor();
237     cursor2.addPhysicalAction("field6", new Integer JavaDoc(2), false);
238
239     try {
240       state.apply(objectID, cursor2, new BackReferences());
241       assertTrue(false);
242     } catch (ClassNotCompatableException cfe) {
243       // expected
244 }
245
246     // recreate the state object, even though we pass old state object, it should extend latest state object
247 PhysicalManagedObjectState state2 = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
248         .recreateState(objectID, ObjectID.NULL_ID, "com.xxx.SomeClassName", loaderDesc, cursor2, state);
249     state2.apply(objectID, cursor2, new BackReferences());
250     cursor.reset();
251     state2.apply(objectID, cursor, new BackReferences());
252
253     assertTrue(state1.getClassId() != state2.getClassId());
254     assertEquals(state2.getClassName(), "com.xxx.SomeClassName");
255     assertEquals(state2.getLoaderDescription(), loaderDesc);
256
257     values = state2.addValues(new HashMap JavaDoc());
258     assertEquals(new ObjectID(2), values.get("field1"));
259     l2 = (Long JavaDoc) values.get("field2");
260     assertEquals(11, l2.longValue());
261     f3 = (String JavaDoc) values.get("field3");
262     assertEquals(f3, "neoistheone");
263     f4 = (Boolean JavaDoc) values.get("field4");
264     assertEquals(f4, new Boolean JavaDoc(false));
265     assertEquals(new ObjectID(22), values.get("field5"));
266     Integer JavaDoc i6 = (Integer JavaDoc) values.get("field6");
267     assertEquals(2, i6.intValue());
268
269     assertEquals(state1.getClass().getName(), state2.getClass().getSuperclass().getName());
270
271     // The same field is changed from Integer to Long, this is not support.
272 cursor2 = new TestDNACursor();
273     cursor2.addPhysicalAction("field6", new Long JavaDoc(2));
274     try {
275       // We print the exception but dont throw it.
276 state2.apply(objectID, cursor2, new BackReferences());
277       System.err.println("The above exception is NORMAL.");
278     } catch (ClassCastException JavaDoc cfe) {
279       assertTrue(false);
280     }
281
282     values = state2.addValues(new HashMap JavaDoc());
283     i6 = (Integer JavaDoc) values.get("field6");
284     assertEquals(2, i6.intValue());
285
286     // Try to create a new State Object
287 cursor = new TestDNACursor();
288     cursor.addPhysicalAction("field1", new ObjectID(1));
289     cursor.addPhysicalAction("field2", new Long JavaDoc(11));
290     cursor.addPhysicalAction("field3", new String JavaDoc("neoistheone"));
291
292     PhysicalManagedObjectState state3 = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance()
293         .createState(objectID, ObjectID.NULL_ID, "com.xxx.SomeClassName", loaderDesc, cursor);
294     state3.apply(objectID, cursor, new BackReferences());
295     assertEquals(state2.getClass().getName(), state3.getClass().getName());
296
297     // RESTART Scenario... still only the new object type should be used
298 cursor.reset();
299     ManagedObjectStateFactory.createInstance(listenerProvider, persistor);
300     state3 = (PhysicalManagedObjectState) ManagedObjectStateFactory.getInstance().createState(objectID,
301                                                                                               ObjectID.NULL_ID,
302                                                                                               "com.xxx.SomeClassName",
303                                                                                               loaderDesc, cursor);
304     state3.apply(objectID, cursor, new BackReferences());
305     assertEquals(state2.getClass().getName(), state3.getClass().getName());
306
307     assertEquals(ObjectID.NULL_ID, state.getParentID());
308   }
309
310 }
311
Popular Tags