KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nanocontainer > aop > dynaop > DynaopPointcutsFactoryTestCase


1 /*****************************************************************************
2  * Copyright (c) PicoContainer Organization. All rights reserved. *
3  * ------------------------------------------------------------------------- *
4  * The software in this package is published under the terms of the BSD *
5  * style license a copy of which has been included with this distribution in *
6  * the LICENSE.txt file. *
7  * *
8  * Idea by Rachel Davies, Original code by various *
9  *****************************************************************************/

10 package org.nanocontainer.aop.dynaop;
11
12 import junit.framework.TestCase;
13 import org.nanocontainer.aop.ClassPointcut;
14 import org.nanocontainer.aop.ComponentPointcut;
15 import org.nanocontainer.aop.MalformedRegularExpressionException;
16 import org.nanocontainer.aop.MethodPointcut;
17 import org.nanocontainer.aop.PointcutsFactory;
18 import org.nanocontainer.testmodel.Dao;
19
20 import java.io.Serializable JavaDoc;
21 import java.lang.reflect.Method JavaDoc;
22
23 /**
24  * @author Stephen Molitor
25  */

26 public class DynaopPointcutsFactoryTestCase extends TestCase {
27
28     private PointcutsFactory cuts = new DynaopPointcutsFactory();
29     private Method JavaDoc apple;
30     private Method JavaDoc apricot;
31     private Method JavaDoc banana;
32     private Method JavaDoc getA;
33     private Method JavaDoc misleadingGetA;
34     private Method JavaDoc isA;
35     private Method JavaDoc getB;
36     private Method JavaDoc isB;
37     private Method JavaDoc setA;
38     private Method JavaDoc setB;
39     private Method JavaDoc equals;
40     private Method JavaDoc hashCode;
41     private Method JavaDoc toString;
42     private Method JavaDoc subFooMethod;
43
44     public void testAllClasses() {
45         ClassPointcut cut = cuts.allClasses();
46         assertTrue(cut.picks(Object JavaDoc.class));
47         assertTrue(cut.picks(Serializable JavaDoc.class));
48         assertTrue(cut.picks(Foo.class));
49         assertTrue(cut.picks(this.getClass()));
50     }
51
52     public void testInstancesOf() {
53         ClassPointcut cut = cuts.instancesOf(Serializable JavaDoc.class);
54         assertTrue(cut.picks(Serializable JavaDoc.class));
55         assertTrue(cut.picks(String JavaDoc.class));
56         assertFalse(cut.picks(Foo.class));
57     }
58
59     public void testClassName() {
60         ClassPointcut cut = cuts.className("Foo*");
61         assertTrue(cut.picks(Foo.class));
62         assertTrue(cut.picks(FooBar.class));
63         assertFalse(cut.picks(Bar.class));
64
65         assertFalse(cuts.className("^Foo*").picks(Foo.class));
66     }
67
68     public void testOneClass() {
69         ClassPointcut cut = cuts.oneClass(Foo.class);
70         assertTrue(cut.picks(Foo.class));
71         assertFalse(cut.picks(FooBar.class));
72     }
73
74     public void testPackageName() {
75         ClassPointcut cut = cuts.packageName("org.nanocontainer.aop.dynaop");
76         assertTrue(cut.picks(Foo.class));
77         assertTrue(cut.picks(Bar.class));
78         assertFalse(cut.picks(org.nanocontainer.testmodel.Dao.class));
79     }
80
81     public void testClassPointcutIntersection() {
82         ClassPointcut a = cuts.union(cuts.oneClass(Foo.class), cuts.oneClass(Bar.class));
83         ClassPointcut b = cuts.union(cuts.oneClass(Foo.class), cuts.oneClass(FooBar.class));
84         ClassPointcut c = cuts.intersection(a, b);
85         assertTrue(c.picks(Foo.class));
86         assertFalse(c.picks(Bar.class));
87         assertFalse(c.picks(FooBar.class));
88     }
89
90     public void testClassPointcutNot() {
91         ClassPointcut cut = cuts.not(cuts.oneClass(Foo.class));
92         assertFalse(cut.picks(Foo.class));
93         assertTrue(cut.picks(Bar.class));
94     }
95
96     public void testClassPointcutUnion() {
97         ClassPointcut cut = cuts.union(cuts.oneClass(Foo.class), cuts.oneClass(Bar.class));
98         assertTrue(cut.picks(Foo.class));
99         assertTrue(cut.picks(Bar.class));
100         assertFalse(cut.picks(FooBar.class));
101     }
102
103     public void testAllMethods() {
104         MethodPointcut cut = cuts.allMethods();
105         Method JavaDoc[] methods = Foo.class.getMethods();
106         for (int i = 0; i < methods.length; ++i) {
107             assertTrue(cut.picks(methods[i]));
108         }
109     }
110
111     public void testGetMethods() {
112         MethodPointcut cut = cuts.getMethods();
113         assertTrue(cut.picks(getA));
114         assertTrue(cut.picks(getB));
115         assertTrue(cut.picks(misleadingGetA));
116         assertFalse(cut.picks(isA));
117         assertFalse(cut.picks(isB));
118         assertFalse(cut.picks(setA));
119         assertFalse(cut.picks(setB));
120         assertFalse(cut.picks(apple));
121         assertFalse(cut.picks(apricot));
122         assertFalse(cut.picks(banana));
123     }
124
125     public void testIsMethods() {
126         MethodPointcut cut = cuts.isMethods();
127         assertFalse(cut.picks(getA));
128         assertFalse(cut.picks(getB));
129         assertTrue(cut.picks(isA));
130         assertTrue(cut.picks(isB));
131         assertFalse(cut.picks(setA));
132         assertFalse(cut.picks(setB));
133         assertFalse(cut.picks(apple));
134         assertFalse(cut.picks(apricot));
135         assertFalse(cut.picks(banana));
136     }
137
138     public void testSetMethods() {
139         MethodPointcut cut = cuts.setMethods();
140         assertFalse(cut.picks(getA));
141         assertFalse(cut.picks(getB));
142         assertFalse(cut.picks(isA));
143         assertFalse(cut.picks(isB));
144         assertTrue(cut.picks(setA));
145         assertTrue(cut.picks(setB));
146         assertFalse(cut.picks(apple));
147         assertFalse(cut.picks(apricot));
148         assertFalse(cut.picks(banana));
149     }
150
151     public void testSignature() {
152         assertTrue(cuts.signature("getA").picks(getA));
153         assertTrue(cuts.signature("getA").picks(misleadingGetA));
154         assertTrue(cuts.signature("getA()").picks(getA));
155         assertTrue(cuts.signature("String getA\\(String\\)").picks(misleadingGetA));
156         assertFalse(cuts.signature("String getA\\(String\\)").picks(getA));
157         assertTrue(cuts.signature("get*").picks(getA));
158         assertTrue(cuts.signature("get*").picks(getB));
159         assertTrue(cuts.signature("get*").picks(misleadingGetA));
160     }
161
162     public void testOneMethod() {
163         MethodPointcut cut = cuts.oneMethod(getA);
164         assertTrue(cut.picks(getA));
165         assertFalse(cut.picks(getB));
166         assertFalse(cut.picks(isA));
167         assertFalse(cut.picks(isB));
168         assertFalse(cut.picks(setA));
169         assertFalse(cut.picks(setB));
170         assertFalse(cut.picks(apple));
171         assertFalse(cut.picks(apricot));
172         assertFalse(cut.picks(banana));
173     }
174
175     public void testReturnType() {
176         MethodPointcut cut = cuts.returnType(cuts.oneClass(String JavaDoc.class));
177         assertTrue(cut.picks(getA));
178         assertTrue(cut.picks(getB));
179         assertFalse(cut.picks(isA));
180         assertFalse(cut.picks(isB));
181         assertFalse(cut.picks(setA));
182         assertFalse(cut.picks(setB));
183         assertFalse(cut.picks(apple));
184         assertFalse(cut.picks(apricot));
185         assertFalse(cut.picks(banana));
186     }
187
188     public void testMethodPointcutIntersection() {
189         MethodPointcut a = cuts.union(cuts.oneMethod(apple), cuts.oneMethod(apricot));
190         MethodPointcut b = cuts.union(cuts.oneMethod(apple), cuts.oneMethod(banana));
191         MethodPointcut c = cuts.intersection(a, b);
192
193         assertTrue(c.picks(apple));
194         assertFalse(c.picks(apricot));
195         assertFalse(c.picks(banana));
196     }
197
198     public void testMethodPointcutNot() {
199         MethodPointcut cut = cuts.not(cuts.oneMethod(getA));
200         assertFalse(cut.picks(getA));
201         assertTrue(cut.picks(getB));
202         assertTrue(cut.picks(isA));
203         assertTrue(cut.picks(isB));
204         assertTrue(cut.picks(setA));
205         assertTrue(cut.picks(setB));
206         assertTrue(cut.picks(apple));
207         assertTrue(cut.picks(apricot));
208         assertTrue(cut.picks(banana));
209     }
210
211     public void testMethodPointcutUnion() {
212         MethodPointcut cut = cuts.union(cuts.oneMethod(apple), cuts.oneMethod(apricot));
213         assertTrue(cut.picks(apple));
214         assertTrue(cut.picks(apricot));
215         assertFalse(cut.picks(banana));
216         assertFalse(cut.picks(getA));
217         assertFalse(cut.picks(getB));
218         assertFalse(cut.picks(isA));
219         assertFalse(cut.picks(isB));
220         assertFalse(cut.picks(setA));
221         assertFalse(cut.picks(setB));
222     }
223
224     public void testComponent() {
225         ComponentPointcut cut = cuts.component(Dao.class);
226         assertTrue(cut.picks(Dao.class));
227         assertFalse(cut.picks("Dao"));
228     }
229
230     public void testComponentName() {
231         ComponentPointcut cut = cuts.componentName("foo*");
232         assertTrue(cut.picks("foo"));
233         assertTrue(cut.picks("foobar"));
234         assertFalse(cut.picks("bar"));
235     }
236
237     public void testMalformedPatternExceptionRethrown() {
238         try {
239             cuts.className("(");
240             fail("MalformedRegularExpressionException should have been raised");
241         } catch (MalformedRegularExpressionException e) {
242         }
243
244         try {
245             cuts.signature("(");
246             fail("MalformedRegularExpressionException should have been raised");
247         } catch (MalformedRegularExpressionException e) {
248         }
249     }
250
251     public void testObjectMethods() {
252         MethodPointcut cut = cuts.objectMethods();
253         assertTrue(cut.picks(equals));
254         assertTrue(cut.picks(hashCode));
255         assertTrue(cut.picks(toString));
256         assertFalse(cut.picks(isA));
257         assertFalse(cut.picks(setA));
258     }
259
260     public void testDeclaringClass() {
261         MethodPointcut cut = cuts.declaringClass(cuts.oneClass(Object JavaDoc.class));
262         assertTrue(cut.picks(equals));
263         assertTrue(cut.picks(hashCode));
264         assertTrue(cut.picks(toString));
265         assertFalse(cut.picks(isA));
266         assertFalse(cut.picks(setA));
267     }
268
269     public void testMembersOf() {
270         MethodPointcut cut = cuts.membersOf(Foo.class);
271         assertTrue(cut.picks(apple));
272         assertTrue(cut.picks(equals));
273         assertFalse(cut.picks(subFooMethod));
274     }
275
276     public void testCustomClassPointcuts() {
277         ClassPointcut picksFoo = new ClassPointcut() {
278             public boolean picks(Class JavaDoc clazz) {
279                 return clazz.equals(Foo.class);
280             }
281         };
282         ClassPointcut picksBar = new ClassPointcut() {
283             public boolean picks(Class JavaDoc clazz) {
284                 return clazz.equals(Bar.class);
285             }
286         };
287         ClassPointcut cut = cuts.union(picksFoo, picksBar);
288         assertTrue(cut.picks(Foo.class));
289         assertTrue(cut.picks(Bar.class));
290         assertFalse(cut.picks(FooBar.class));
291     }
292
293     public void testCustomMethodPointcuts() {
294         MethodPointcut picksApple = new MethodPointcut() {
295             public boolean picks(Method JavaDoc method) {
296                 return method.equals(apple);
297             }
298         };
299         MethodPointcut picksApricot = new MethodPointcut() {
300             public boolean picks(Method JavaDoc method) {
301                 return method.equals(apricot);
302             }
303         };
304         MethodPointcut cut = cuts.union(picksApple, picksApricot);
305         assertTrue(cut.picks(apple));
306         assertTrue(cut.picks(apricot));
307         assertFalse(cut.picks(banana));
308     }
309
310     protected void setUp() throws Exception JavaDoc {
311         super.setUp();
312         apple = Foo.class.getMethod("apple", new Class JavaDoc[]{});
313         apricot = Foo.class.getMethod("apricot", new Class JavaDoc[]{});
314         banana = Foo.class.getMethod("banana", new Class JavaDoc[]{});
315         getA = Foo.class.getMethod("getA", new Class JavaDoc[]{});
316         misleadingGetA = Foo.class.getMethod("getA", new Class JavaDoc[]{String JavaDoc.class});
317         isA = Foo.class.getMethod("isA", new Class JavaDoc[]{});
318         getB = Foo.class.getMethod("getB", new Class JavaDoc[]{});
319         isB = Foo.class.getMethod("isB", new Class JavaDoc[]{});
320         setA = Foo.class.getMethod("setA", new Class JavaDoc[]{String JavaDoc.class});
321         setB = Foo.class.getMethod("setA", new Class JavaDoc[]{String JavaDoc.class});
322         equals = Object JavaDoc.class.getMethod("equals", new Class JavaDoc[]{Object JavaDoc.class});
323         hashCode = Object JavaDoc.class.getMethod("hashCode", new Class JavaDoc[]{});
324         toString = Object JavaDoc.class.getMethod("toString", new Class JavaDoc[]{});
325         subFooMethod = SubFoo.class.getMethod("subFooMethod", new Class JavaDoc[]{});
326     }
327
328 }
Popular Tags