KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > test > aop > jdk15 > dynamic > prepareConstructor > HotSwapEnabledTester


1 /*
2   * JBoss, Home of Professional Open Source
3   * Copyright 2005, JBoss Inc., and individual contributors as indicated
4   * by the @authors tag. See the copyright.txt in the distribution for a
5   * full listing of individual contributors.
6   *
7   * This is free software; you can redistribute it and/or modify it
8   * under the terms of the GNU Lesser General Public License as
9   * published by the Free Software Foundation; either version 2.1 of
10   * the License, or (at your option) any later version.
11   *
12   * This software is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * Lesser General Public License for more details.
16   *
17   * You should have received a copy of the GNU Lesser General Public
18   * License along with this software; if not, write to the Free
19   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21   */

22 package org.jboss.test.aop.jdk15.dynamic.prepareConstructor;
23
24 import org.jboss.test.aop.AOPTestDelegate;
25 import org.jboss.test.aop.AOPTestWithSetup;
26 import org.jboss.test.aop.jdk15.dynamic.common.BindingInterceptor;
27 import org.jboss.test.aop.jdk15.dynamic.common.InstanceInterceptor;
28 import org.jboss.test.aop.jdk15.dynamic.common.InterceptionsCount;
29 import org.jboss.test.aop.jdk15.dynamic.common.POJOWrappingInfo;
30 import org.jboss.test.aop.jdk15.dynamic.common.ScenarioLoader;
31
32 /**
33  * TestCase that checks the jboss aop behaviour in dynamic aop operations
34  * performed with hot swap enabled. The aop operations target class, (POJO class)
35  * was configured to have only the construction execution joinpoint prepared.
36  * @author Flavia Rainone
37  */

38 public class HotSwapEnabledTester extends AOPTestWithSetup
39 {
40    private ScenarioLoader scenarioLoader;
41    
42  
43    public HotSwapEnabledTester(String JavaDoc name)
44    {
45       super(name);
46    }
47
48    /**
49     * Runs before each test method.
50     */

51    public void setUp() throws Exception JavaDoc
52    {
53       super.setUp();
54       this.scenarioLoader = new ScenarioLoader(((AOPTestDelegate)getDelegate()).getSystemProperties());
55    }
56    
57    /**
58     * Asserts no pojo joinpoints are wrapped.
59     * @param wrappingInfo contains the joinpoints wrapping information to be checked.
60     */

61    private void assertUnwrapped(POJOWrappingInfo wrappingInfo)
62    {
63       assertFalse(wrappingInfo.isConstructorWrapped());
64       assertFalse(wrappingInfo.isFieldReadWrapped());
65       assertFalse(wrappingInfo.isFieldWriteWrapped());
66       assertFalse(wrappingInfo.isMethodWrapped());
67    }
68    
69    /**
70     * Asserts all pojo joinpoints are wrapped.
71     * @param wrappingInfo contains the joinpoints wrapping information to be checked.
72     */

73    private void assertFullyWrapped(POJOWrappingInfo wrappingInfo)
74    {
75       assertTrue(wrappingInfo.isConstructorWrapped());
76       assertTrue(wrappingInfo.isFieldReadWrapped());
77       assertTrue(wrappingInfo.isFieldWriteWrapped());
78       assertTrue(wrappingInfo.isMethodWrapped());
79    }
80    
81    /**
82     * Asserts only pojo constructor execution joinpoint is wrapped.
83     * @param wrappingInfo contains the joinpoints wrapping information to be checked.
84     */

85    private void assertOnlyConstructorWrapped(POJOWrappingInfo wrappingInfo)
86    {
87       assertTrue(wrappingInfo.isConstructorWrapped());
88       assertFalse(wrappingInfo.isFieldReadWrapped());
89       assertFalse(wrappingInfo.isFieldWriteWrapped());
90       assertFalse(wrappingInfo.isMethodWrapped());
91    }
92    
93    /**
94     * Runs "interceptPerClassLoadAfter" scenario and checks which
95     * interceptions were performed.
96     * @throws Throwable
97     * @see ScenarioLoader#interceptPerClassLoadAfter()
98     */

99    public void testPerClassLoadAfterInterception() throws Throwable JavaDoc
100    {
101       // run scenario
102
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassLoadAfter();
103       // check wrapping status
104
assertFullyWrapped(wrappingInfos[0]);
105       assertUnwrapped(wrappingInfos[1]);
106       // check interception counts
107
InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
108       assertEquals(0, instance.total);
109       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
110       assertTrue(binding.total >= 5 && binding.total <= 8);
111       assertTrue(binding.constructor >= 1 && binding.constructor <= 2);
112       assertTrue(binding.fieldRead >= 1 && binding.fieldRead <= 2);
113       assertTrue(binding.fieldWrite >= 1 && binding.fieldWrite <= 2);
114       assertEquals(2, binding.method);
115    }
116    
117    /**
118     * Runs "interceptPerClassLoadBefore" scenario and checks which
119     * interceptions were performed.
120     * @throws Throwable
121     * @see ScenarioscenarioLoader#interceptPerClassLoadBefore()
122     */

123    public void testPerClassLoadBeforeInterception() throws Throwable JavaDoc
124    {
125       // run scenario
126
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassLoadBefore();
127       // check wrapping status
128
assertUnwrapped(wrappingInfos[0]);
129       assertOnlyConstructorWrapped(wrappingInfos[1]);
130       assertUnwrapped(wrappingInfos[2]);
131       // check interception counts
132
InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
133       assertEquals(0, instance.total);
134       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
135       assertTrue(binding.total >= 1 && binding.total <= 2);
136       assertTrue(binding.constructor >= 1 && binding.constructor <=2);
137       assertEquals(0, binding.fieldRead);
138       assertEquals(0, binding.fieldWrite);
139       assertEquals(0, binding.method);
140    }
141
142    /**
143     * Runs "addAndRemoveBindingTwice" scenario and checks which
144     * interceptions were performed.
145     * @throws Throwable
146     * @see ScenarioLoader#interceptPerClassLoadBefore()
147     */

148    public void testAddAndRemoveBindingTwice() throws Throwable JavaDoc
149    {
150       // run scenario
151
POJOWrappingInfo[] wrappingInfos = scenarioLoader.addAndRemoveBindingTwice();
152       // check wrapping status
153
assertUnwrapped(wrappingInfos[0]);
154       assertOnlyConstructorWrapped(wrappingInfos[1]);
155       assertUnwrapped(wrappingInfos[2]);
156       assertOnlyConstructorWrapped(wrappingInfos[3]);
157       assertUnwrapped(wrappingInfos[4]);
158       // check interception counts
159
InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
160       assertEquals(0, instance.total);
161       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
162       assertEquals(2, binding.total);
163       assertEquals(2, binding.constructor);
164       assertEquals(0, binding.fieldRead);
165       assertEquals(0, binding.fieldWrite);
166       assertEquals(0, binding.method);
167    }
168    
169    /**
170     * Runs "interceptPerInstance" scenario and checks which
171     * interceptions were performed.
172     * @throws Throwable
173     * @see ScenarioLoader#interceptPerInstance()
174     */

175    public void testPerInstanceInterception() throws Throwable JavaDoc
176    {
177       // run scenario
178
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstance();
179       // check wrapping status
180
assertUnwrapped(wrappingInfos[0]);
181       assertOnlyConstructorWrapped(wrappingInfos[1]);
182       // check interception counts
183
InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
184       assertEquals(0, binding.total);
185       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
186       assertEquals(0, instance.total);
187    }
188
189    
190    /**
191     * Runs "interceptPerInstanceGC" scenario and checks which
192     * interceptions were performed.
193     * @throws Throwable
194     * @see ScenarioLoader#interceptPerInstanceGC()
195     */

196    public void testPerInstanceGcInterception() throws Throwable JavaDoc
197    {
198       // run scenario
199
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstanceGC();
200       // check wrapping status
201
assertUnwrapped(wrappingInfos[0]);
202       assertOnlyConstructorWrapped(wrappingInfos[1]);
203       assertUnwrapped(wrappingInfos[2]);
204       // check interception counts
205
InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
206       assertEquals(0, binding.total);
207       // result of the time the JVMTI takes to hot swap classes
208
InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
209       assertEquals(0, instance.total);
210    }
211    
212    /**
213     * Runs "interceptPerClassPerInstance" scenario and checks which
214     * interceptions were performed.
215     * @throws Throwable
216     * @see ScenarioLoader#interceptPerClassPerInstance()
217     */

218    public void testPerClassPerInstanceInterception() throws Throwable JavaDoc
219    {
220       // run scenario
221
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassPerInstance();
222       // check wrapping status
223
assertUnwrapped(wrappingInfos[0]);
224       assertOnlyConstructorWrapped(wrappingInfos[1]);
225       assertOnlyConstructorWrapped(wrappingInfos[2]);
226       // check interception counts
227
InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
228       assertEquals(1, binding.total);
229       assertEquals(1, binding.constructor);
230       assertEquals(0, binding.fieldRead);
231       assertEquals(0, binding.fieldWrite);
232       assertEquals(0, binding.method);
233       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
234       assertEquals(0, instance.total);
235    }
236    
237    /**
238     * Runs "interceptPerInstancePerClass" scenario and checks which
239     * interceptions were performed.
240     * @throws Throwable
241     * @see ScenarioLoader#interceptPerInstancePerClass()
242     */

243    public void testPerInstancePerClassInterception() throws Throwable JavaDoc
244    {
245       // run scenario
246
POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstancePerClass();
247       // check wrapping status
248
assertOnlyConstructorWrapped(wrappingInfos[0]);
249       assertOnlyConstructorWrapped(wrappingInfos[1]);
250       assertOnlyConstructorWrapped(wrappingInfos[2]);
251       // check interception counts
252
InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
253       assertEquals(1, binding.total);
254       assertEquals(1, binding.constructor);
255       assertEquals(0, binding.fieldRead);
256       assertEquals(0, binding.fieldWrite);
257       assertEquals(0, binding.method);
258       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
259       assertEquals(0, instance.total);
260       assertEquals(0, instance.constructor);
261    }
262    
263    /**
264     * Runs "executeAfterBindingRemoval" scenario and checks which
265     * interceptions were performed.
266     * @throws Throwable
267     * @see ScenarioLoader#executeAfterBindingRemoval()
268     */

269    public void testAfterBindingRemovalExecution() throws Throwable JavaDoc
270    {
271       POJOWrappingInfo[] wrappingInfos = scenarioLoader.executeAfterBindingRemoval();
272       assertUnwrapped(wrappingInfos[0]);
273       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
274       assertEquals(0, binding.total);
275       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
276       assertEquals(0, instance.total);
277    }
278 }
Popular Tags