KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tctest > EnumTestApp


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.tctest;
6
7 import com.tc.object.config.ConfigVisitor;
8 import com.tc.object.config.DSOClientConfigHelper;
9 import com.tc.object.config.TransparencyClassSpec;
10 import com.tc.simulator.app.ApplicationConfig;
11 import com.tc.simulator.listener.ListenerProvider;
12 import com.tc.util.Assert;
13 import com.tctest.runner.AbstractTransparentApp;
14
15 import java.util.Arrays JavaDoc;
16 import java.util.HashMap JavaDoc;
17 import java.util.Map JavaDoc;
18 import java.util.concurrent.CyclicBarrier JavaDoc;
19
20 public class EnumTestApp extends AbstractTransparentApp {
21
22   private final DataRoot dataRoot = new DataRoot();
23   private final CyclicBarrier JavaDoc barrier;
24   private final Map JavaDoc raceRoot = new HashMap JavaDoc();
25
26   private State stateRoot;
27
28   public EnumTestApp(String JavaDoc appId, ApplicationConfig cfg, ListenerProvider listenerProvider) {
29     super(appId, cfg, listenerProvider);
30     barrier = new CyclicBarrier JavaDoc(getParticipantCount());
31   }
32
33   public void run() {
34     try {
35       int index = barrier.await();
36       
37       rootEnumTest(index);
38
39       if (index == 0) {
40         stateRoot = State.START;
41       }
42       
43       barrier.await();
44       
45       Assert.assertTrue(stateRoot == State.START);
46       
47       barrier.await();
48
49       if (index == 1) {
50         stateRoot = State.RUN;
51       }
52
53       barrier.await();
54
55       Assert.assertTrue(stateRoot == State.RUN);
56
57       barrier.await();
58
59       for (int i = 0; i < 100; i++) {
60         if (index == 0) {
61           stateRoot = State.START;
62         } else {
63           stateRoot = State.RUN;
64         }
65       }
66
67       barrier.await();
68
69       if (index == 0) {
70         dataRoot.setState(State.START);
71       }
72
73       barrier.await();
74
75       Assert.assertTrue(dataRoot.getState() == State.START);
76       Assert.assertEquals(0, dataRoot.getState().getStateNum());
77
78       barrier.await();
79
80       if (index == 1) {
81         dataRoot.setState(State.RUN);
82         dataRoot.getState().setStateNum(10);
83       }
84
85       barrier.await();
86
87       Assert.assertTrue(dataRoot.getState() == State.RUN);
88       if (index == 1) {
89         Assert.assertEquals(10, dataRoot.getState().getStateNum());
90       } else {
91         // Mutation in enum is not supported.
92
Assert.assertEquals(1, dataRoot.getState().getStateNum());
93       }
94
95       barrier.await();
96
97       if (index == 0) {
98         dataRoot.setState(State.STOP);
99       }
100
101       barrier.await();
102
103       Assert.assertTrue(dataRoot.getState() == State.STOP);
104       Assert.assertEquals(2, dataRoot.getState().getStateNum());
105
106       barrier.await();
107
108       if (index == 0) {
109         dataRoot.setStates(State.values().clone());
110       }
111
112       barrier.await();
113
114       Assert.assertEquals(3, dataRoot.getStates().length);
115       Assert.assertTrue(Arrays.equals(State.values(), dataRoot.getStates()));
116       
117       if (index == 0) {
118         testRace();
119       }
120
121       if (index == 0) {
122         testRace();
123       }
124
125     } catch (Throwable JavaDoc t) {
126       notifyError(t);
127     }
128   }
129   
130   // Don't reference this enum in any other methods except testRace() please
131
enum EnumForRace {
132     V1, V2, V3;
133   }
134
135   private static class Ref {
136     private final EnumForRace e;
137
138     Ref(EnumForRace e) {
139       this.e = e;
140     }
141
142     public String JavaDoc toString() {
143       return "ref(" + e + ")";
144     }
145   }
146
147   private void testRace() throws InterruptedException JavaDoc {
148     final Object JavaDoc lock1 = new Object JavaDoc();
149     final Object JavaDoc lock2 = new Object JavaDoc();
150
151     synchronized (raceRoot) {
152       raceRoot.put("lock1", lock1);
153       raceRoot.put("lock1", lock2);
154     }
155
156     final CyclicBarrier JavaDoc cb = new CyclicBarrier JavaDoc(2);
157     final EnumForRace enumInstance = EnumForRace.V1;
158
159     Thread JavaDoc other = new Thread JavaDoc() {
160       public void run() {
161         shareWithLock(lock1, new Ref(enumInstance), raceRoot, cb);
162       }
163     };
164     other.start();
165
166     shareWithLock(lock2, new Ref(enumInstance), raceRoot, cb);
167
168     other.join();
169   }
170
171   private static void shareWithLock(Object JavaDoc lock, Object JavaDoc toShare, Map JavaDoc root, CyclicBarrier JavaDoc barrier) {
172     synchronized (lock) {
173       root.put(String.valueOf(System.identityHashCode(lock)), toShare);
174
175       try {
176         barrier.await();
177       } catch (Exception JavaDoc e) {
178         throw new RuntimeException JavaDoc(e);
179       }
180     }
181   }
182
183   private void rootEnumTest(int index) throws Exception JavaDoc {
184     if (index == 0) {
185       stateRoot = State.START;
186     }
187
188     barrier.await();
189
190     Assert.assertEquals(State.START, stateRoot);
191
192     barrier.await();
193
194     if (index == 1) {
195       stateRoot = State.RUN;
196     }
197
198     barrier.await();
199
200     Assert.assertEquals(State.RUN, stateRoot);
201
202     barrier.await();
203   }
204
205   public static void visitL1DSOConfig(ConfigVisitor visitor, DSOClientConfigHelper config) {
206     String JavaDoc testClass = EnumTestApp.class.getName();
207     TransparencyClassSpec spec = config.getOrCreateSpec(testClass);
208
209     config.addIncludePattern(testClass + "$DataRoot*");
210
211     String JavaDoc methodExpression = "* " + testClass + "*.*(..)";
212     config.addWriteAutolock(methodExpression);
213
214     methodExpression = "* " + testClass + "$DataRoot*.*(..)";
215     config.addWriteAutolock(methodExpression);
216
217     spec.addRoot("barrier", "barrier");
218     spec.addRoot("dataRoot", "dataRoot");
219     spec.addRoot("stateRoot", "stateRoot", false);
220     spec.addRoot("raceRoot", "raceRoot");
221
222     // explicitly including the enum class here exposes a bug,
223
// generally an enum type doesn't need to be included to be shared
224
config.addIncludePattern(EnumForRace.class.getName());
225     config.addIncludePattern(Ref.class.getName());
226   }
227
228   public enum State {
229     START(0), RUN(1), STOP(2);
230
231     private int stateNum;
232
233     State(int stateNum) {
234       this.stateNum = stateNum;
235     }
236
237     int getStateNum() {
238       return this.stateNum;
239     }
240
241     void setStateNum(int stateNum) {
242       this.stateNum = stateNum;
243     }
244   }
245
246   private static class DataRoot {
247     private State state;
248     private State states[];
249
250     public DataRoot() {
251       super();
252     }
253
254     public synchronized void setState(State state) {
255       this.state = state;
256     }
257
258     public synchronized State getState() {
259       return state;
260     }
261
262     public synchronized State[] getStates() {
263       return states;
264     }
265
266     public synchronized void setStates(State[] states) {
267       this.states = states;
268     }
269
270   }
271 }
272
Popular Tags