|
1
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  ;
21 import java.lang.reflect.Method ;
22
23
26 public class DynaopPointcutsFactoryTestCase extends TestCase {
27
28 private PointcutsFactory cuts = new DynaopPointcutsFactory();
29 private Method apple;
30 private Method apricot;
31 private Method banana;
32 private Method getA;
33 private Method misleadingGetA;
34 private Method isA;
35 private Method getB;
36 private Method isB;
37 private Method setA;
38 private Method setB;
39 private Method equals;
40 private Method hashCode;
41 private Method toString;
42 private Method subFooMethod;
43
44 public void testAllClasses() {
45 ClassPointcut cut = cuts.allClasses();
46 assertTrue(cut.picks(Object .class));
47 assertTrue(cut.picks(Serializable .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 .class);
54 assertTrue(cut.picks(Serializable .class));
55 assertTrue(cut.picks(String .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 [] 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 .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 .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 clazz) {
279 return clazz.equals(Foo.class);
280 }
281 };
282 ClassPointcut picksBar = new ClassPointcut() {
283 public boolean picks(Class 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 method) {
296 return method.equals(apple);
297 }
298 };
299 MethodPointcut picksApricot = new MethodPointcut() {
300 public boolean picks(Method 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 {
311 super.setUp();
312 apple = Foo.class.getMethod("apple", new Class []{});
313 apricot = Foo.class.getMethod("apricot", new Class []{});
314 banana = Foo.class.getMethod("banana", new Class []{});
315 getA = Foo.class.getMethod("getA", new Class []{});
316 misleadingGetA = Foo.class.getMethod("getA", new Class []{String .class});
317 isA = Foo.class.getMethod("isA", new Class []{});
318 getB = Foo.class.getMethod("getB", new Class []{});
319 isB = Foo.class.getMethod("isB", new Class []{});
320 setA = Foo.class.getMethod("setA", new Class []{String .class});
321 setB = Foo.class.getMethod("setA", new Class []{String .class});
322 equals = Object .class.getMethod("equals", new Class []{Object .class});
323 hashCode = Object .class.getMethod("hashCode", new Class []{});
324 toString = Object .class.getMethod("toString", new Class []{});
325 subFooMethod = SubFoo.class.getMethod("subFooMethod", new Class []{});
326 }
327
328 }
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.