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.prepareFieldGet;
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 field read joinpoints prepared.
36   * @author Flavia Rainone
37   */
38  public class HotSwapEnabledTester extends AOPTestWithSetup
39  {
40     private ScenarioLoader scenarioLoader;
41     
42     public HotSwapEnabledTester(String   name)
43     {
44        super(name);
45     }
46  
47     /**
48      * Runs before each test method.
49      */
50     public void setUp() throws Exception  
51     {
52        super.setUp();
53        this.scenarioLoader = new ScenarioLoader(((AOPTestDelegate)getDelegate()).getSystemProperties());
54     }
55     
56     /**
57      * Asserts no pojo joinpoints are wrapped.
58      * @param wrappingInfo contains the joinpoints wrapping information to be checked.
59      */
60     private void assertUnwrapped(POJOWrappingInfo wrappingInfo)
61     {
62        assertFalse(wrappingInfo.isConstructorWrapped());
63        assertFalse(wrappingInfo.isFieldReadWrapped());
64        assertFalse(wrappingInfo.isFieldWriteWrapped());
65        assertFalse(wrappingInfo.isMethodWrapped());
66     }
67     
68     /**
69      * Asserts all pojo joinpoints are wrapped.
70      * @param wrappingInfo contains the joinpoints wrapping information to be checked.
71      */
72     private void assertFullyWrapped(POJOWrappingInfo wrappingInfo)
73     {
74        assertTrue(wrappingInfo.isConstructorWrapped());
75        assertTrue(wrappingInfo.isFieldReadWrapped());
76        assertTrue(wrappingInfo.isFieldWriteWrapped());
77        assertTrue(wrappingInfo.isMethodWrapped());
78     }
79     
80     /**
81      * Asserts only field read joinpoints are wrapped.
82      * @param wrappingInfo contains the joinpoints wrapping information to be checked.
83      */
84     private void assertOnlyFieldReadWrapped(POJOWrappingInfo wrappingInfo)
85     {
86        assertFalse(wrappingInfo.isConstructorWrapped());
87        assertTrue(wrappingInfo.isFieldReadWrapped());
88        assertFalse(wrappingInfo.isFieldWriteWrapped());
89        assertFalse(wrappingInfo.isMethodWrapped());
90     }
91     
92     /**
93      * Runs "interceptPerClassLoadAfter" scenario and checks which
94      * interceptions were performed.
95      * @throws Throwable 
96      * @see ScenarioLoader#interceptPerClassLoadAfter()
97      */
98     public void testPerClassLoadAfterInterception() throws Throwable  
99     {
100       // run scenario
101       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassLoadAfter();
102       // check wrapping status
103       assertFullyWrapped(wrappingInfos[0]);
104       assertUnwrapped(wrappingInfos[1]);
105       // check interception counts
106       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
107       assertEquals(0, instance.total);
108       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
109       assertTrue(binding.total >= 5 && binding.total <= 8);
110       assertTrue(binding.constructor >= 1 && binding.constructor <= 2);
111       assertTrue(binding.fieldRead >= 1 && binding.fieldRead <= 2);
112       assertTrue(binding.fieldWrite >= 1 && binding.fieldWrite <= 2);
113       assertEquals(2, binding.method);
114    }
115    
116    /**
117     * Runs "interceptPerClassLoadBefore" scenario and checks which
118     * interceptions were performed.
119     * @throws Throwable 
120     * @see ScenarioscenarioLoader#interceptPerClassLoadBefore()
121     */
122    public void testPerClassLoadBeforeInterception() throws Throwable  
123    {
124       // run scenario
125       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassLoadBefore();
126       // check wrapping status
127       assertUnwrapped(wrappingInfos[0]);
128       assertOnlyFieldReadWrapped(wrappingInfos[1]);
129       assertUnwrapped(wrappingInfos[2]);
130       // check interception counts
131       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
132       assertEquals(0, instance.total);
133       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
134       assertEquals(1, binding.total);
135       assertEquals(0, binding.constructor);
136       assertEquals(1, binding.fieldRead);
137       assertEquals(0, binding.fieldWrite);
138       assertEquals(0, binding.method);
139    }
140 
141    /**
142     * Runs "addAndRemoveBindingTwice" scenario and checks which
143     * interceptions were performed.
144     * @throws Throwable 
145     * @see ScenarioLoader#interceptPerClassLoadBefore()
146     */
147    public void testAddAndRemoveBindingTwice() throws Throwable  
148    {
149       // run scenario
150       POJOWrappingInfo[] wrappingInfos = scenarioLoader.addAndRemoveBindingTwice();
151       // check wrapping status
152       assertUnwrapped(wrappingInfos[0]);
153       assertOnlyFieldReadWrapped(wrappingInfos[1]);
154       assertUnwrapped(wrappingInfos[2]);
155       assertOnlyFieldReadWrapped(wrappingInfos[3]);
156       assertUnwrapped(wrappingInfos[4]);
157       // check interception counts
158       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
159       assertEquals(0, instance.total);
160       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
161       assertEquals(2, binding.total);
162       assertEquals(0, binding.constructor);
163       assertEquals(2, binding.fieldRead);
164       assertEquals(0, binding.fieldWrite);
165       assertEquals(0, binding.method);
166    }
167    
168    /**
169     * Runs "interceptPerInstance" scenario and checks which
170     * interceptions were performed.
171     * @throws Throwable 
172     * @see ScenarioLoader#interceptPerInstance()
173     */
174    public void testPerInstanceInterception() throws Throwable  
175    {
176       // run scenario
177       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstance();
178       // check wrapping status
179       assertUnwrapped(wrappingInfos[0]);
180       assertOnlyFieldReadWrapped(wrappingInfos[1]);
181       // check interception counts      
182       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
183       assertEquals(0, binding.total);
184       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
185       assertTrue(instance.total >= 1 && instance.total <= 2);
186       assertEquals(0, instance.constructor);
187       assertTrue(instance.fieldRead >= 1 && instance.fieldRead <= 2);
188       assertEquals(0, instance.fieldWrite);
189       assertEquals(0, instance.method);
190    }
191 
192    
193    /**
194     * Runs "interceptPerInstanceGC" scenario and checks which
195     * interceptions were performed.
196     * @throws Throwable 
197     * @see ScenarioLoader#interceptPerInstanceGC()
198     */
199    public void testPerInstanceGcInterception() throws Throwable  
200    {
201       // run scenario
202       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstanceGC();
203       // check wrapping status
204       assertUnwrapped(wrappingInfos[0]);
205       assertOnlyFieldReadWrapped(wrappingInfos[1]);
206       assertUnwrapped(wrappingInfos[2]);
207       // check interception counts
208       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
209       assertEquals(0, binding.total);
210       // result of the time the JVMTI takes to hot swap classes
211       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
212       assertTrue(instance.total >= 1 && instance.total <= 2);
213       assertEquals(0, instance.constructor);
214       assertTrue(instance.fieldRead >= 1 && instance.fieldRead <= 2);
215       assertEquals(0, instance.fieldWrite);
216       assertEquals(0, instance.method);
217    }
218    
219    /**
220     * Runs "interceptPerClassPerInstance" scenario and checks which
221     * interceptions were performed.
222     * @throws Throwable 
223     * @see ScenarioLoader#interceptPerClassPerInstance()
224     */
225    public void testPerClassPerInstanceInterception() throws Throwable  
226    {
227       // run scenario
228       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerClassPerInstance();
229       // check wrapping status
230       assertUnwrapped(wrappingInfos[0]);
231       assertOnlyFieldReadWrapped(wrappingInfos[1]);
232       assertOnlyFieldReadWrapped(wrappingInfos[2]);
233       // check interception counts
234       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
235       assertEquals(1, binding.total);
236       assertEquals(0, binding.constructor);
237       assertEquals(1, binding.fieldRead);
238       assertEquals(0, binding.fieldWrite);
239       assertEquals(0, binding.method);
240       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
241       assertEquals(1, instance.total);
242       assertEquals(1, instance.fieldRead);
243       assertEquals(0, instance.fieldWrite);
244    }
245    
246    /**
247     * Runs "interceptPerInstancePerClass" scenario and checks which
248     * interceptions were performed.
249     * @throws Throwable 
250     * @see ScenarioLoader#interceptPerInstancePerClass()
251     */
252    public void testPerInstancePerClassInterception() throws Throwable  
253    {
254       // run scenario
255       POJOWrappingInfo[] wrappingInfos = scenarioLoader.interceptPerInstancePerClass();
256       // check wrapping status
257       assertOnlyFieldReadWrapped(wrappingInfos[0]);
258       assertOnlyFieldReadWrapped(wrappingInfos[1]);
259       assertOnlyFieldReadWrapped(wrappingInfos[2]);
260       // check interception counts      
261       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
262       assertEquals(1, binding.total);
263       assertEquals(0, binding.constructor);
264       assertEquals(1, binding.fieldRead);
265       assertEquals(0, binding.fieldWrite);
266       assertEquals(0, binding.method);
267       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
268       assertTrue(instance.total >= 2 && instance.total <= 3);
269       assertEquals(0, instance.constructor);
270       assertTrue(instance.fieldRead >= 2 && instance.fieldRead <= 3);
271       assertEquals(0, instance.fieldWrite);
272       assertEquals(0, instance.method);
273    }
274    
275    /**
276     * Runs "executeAfterBindingRemoval" scenario and checks which
277     * interceptions were performed.
278     * @throws Throwable 
279     * @see ScenarioLoader#executeAfterBindingRemoval()
280     */
281    public void testAfterBindingRemovalExecution() throws Throwable  
282    {
283       POJOWrappingInfo[] wrappingInfos = scenarioLoader.executeAfterBindingRemoval();
284       assertUnwrapped(wrappingInfos[0]);
285       InterceptionsCount binding = BindingInterceptor.getInterceptionsCount();
286       assertEquals(0, binding.total);
287       InterceptionsCount instance = InstanceInterceptor.getInterceptionsCount();
288       assertEquals(0, instance.total);
289    }
290 }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags