|
1
8 package test;
9
10 import junit.framework.TestCase;
11
12
15 public class StaticMethodAdviceTest extends TestCase {
16 private static String  m_logString = "";
17
18 public StaticMethodAdviceTest() {
19 }
20
21 public StaticMethodAdviceTest(String name) {
22 super(name);
23 }
24
25 public void testMethodAdvice() {
26 m_logString = "";
27 methodAdvicedMethod();
28 assertEquals("before1 invocation after1 ", m_logString);
29 }
30
31 public void testMethodAdviceNewThread() {
32 m_logString = "";
33 methodAdvicedMethodNewThread();
34 assertEquals("before invocation after ", m_logString);
35 }
36
37 public void testMultipleChainedMethodAdvices() {
38 m_logString = "";
39 multipleChainedMethodAdvicedMethod();
40 assertEquals("before1 before2 invocation after2 after1 ", m_logString);
41 }
42
43 public void testMultiplePointcuts() {
44 try {
45 m_logString = "";
46 multiplePointcutsMethod();
47 assertEquals("before1 before2 invocation after2 after1 ", m_logString);
48 } catch (Throwable t) {
49 t.printStackTrace();
50 }
51 }
52
53 public void testGetJoinPointMetaData() {
54 String param = "parameter";
55 String pointcutName = joinPointMetaData(param);
56 assertEquals(
57 "test.StaticMethodAdviceTestjoinPointMetaDataparameterjava.lang.Stringjava.lang.Stringresult",
58 pointcutName
59 );
60 }
61
62 public void testHasPointcutButNoAdvice() {
63 try {
64 hasPointcutButNoAdvice();
65 } catch (Exception e) {
66 fail();
67 }
68 }
69
70 public void testAnonymousAdviced() {
71 try {
72 anonymousAdviced();
73 } catch (Exception e) {
74 fail();
75 }
76 }
77
78 public void testReturnPrimitiveAndNullFromAdvice() {
79 try {
80 assertEquals(0L, getPrimitiveAndNullFromAdvice());
81 } catch (NullPointerException e) {
82 fail(
83 "If method that returns a primitive has an advice that returns NULL then it causes a NPE. The NULL should be handled in bytecode and it should return the default value for the primitive (wrapped)"
84 );
85 }
86 }
87
88 public void testReturnVoid() {
89 getVoid();
90 }
91
92 public void testReturnLong() {
93 assertEquals(1L, getLong());
94 }
95
96 public void testReturnInt() {
98 assertEquals(1, getInt());
99 }
100
101 public void testReturnShort() {
102 assertEquals(1, getShort());
103 }
104
105 public void testReturnDouble() {
106 assertEquals(new Double (1.1D), new Double (getDouble()));
107 }
108
109 public void testReturnFloat() {
110 assertEquals(new Float (1.1F), new Float (getFloat()));
111 }
112
113 public void testReturnByte() {
114 assertEquals(Byte.parseByte("1"), getByte());
115 }
116
117 public void testReturnChar() {
118 assertEquals('A', getChar());
119 }
120
121 public void testReturnBoolean() {
122 assertEquals(true, getBoolean());
123 }
124
125 public void testNoArgs() {
126 noParams();
127 }
128
129 public void testIntArg() {
130 assertEquals(12, intParam(12));
131 }
132
133 public void testLongArg() {
134 assertEquals(12L, longParam(12L));
135 }
136
137 public void testShortArg() {
138 assertEquals(3, shortParam((short) 3));
139 }
140
141 public void testDoubleArg() {
142 assertEquals(new Double (2.3D), new Double (doubleParam(2.3D)));
143 }
144
145 public void testFloatArg() {
146 assertEquals(new Float (2.3F), new Float (floatParam(2.3F)));
147 }
148
149 public void testByteArg() {
150 assertEquals(Byte.parseByte("1"), byteParam(Byte.parseByte("1")));
151 }
152
153 public void testCharArg() {
154 assertEquals('B', charParam('B'));
155 }
156
157 public void testBooleanArg() {
158 assertEquals(false, booleanParam(false));
159 }
160
161 public void testObjectArg() {
162 assertEquals(this, objectParam(this));
163 }
164
165 public void testShortArrayArg() {
166 short[] array = new short[]{
167 1, 2, 3
168 };
169 assertTrue(shortArrayParam(array)[0] == array[0]);
170 assertTrue(shortArrayParam(array)[1] == array[1]);
171 assertTrue(shortArrayParam(array)[2] == array[2]);
172 }
173
174 public void testBooleanArrayArg() {
175 boolean[] array = new boolean[]{
176 true, false
177 };
178 assertTrue(booleanArrayParam(array)[0] == array[0]);
179 assertTrue(booleanArrayParam(array)[1] == array[1]);
180 }
181
182 public void testByteArrayArg() {
183 byte[] array = new byte[]{
184 1, 2, 3
185 };
186 assertTrue(byteArrayParam(array)[0] == array[0]);
187 assertTrue(byteArrayParam(array)[1] == array[1]);
188 assertTrue(byteArrayParam(array)[2] == array[2]);
189 }
190
191 public void testCharArrayArg() {
192 char[] array = new char[]{
193 'A', 'B', 'C'
194 };
195 assertTrue(charArrayParam(array)[0] == array[0]);
196 assertTrue(charArrayParam(array)[1] == array[1]);
197 assertTrue(charArrayParam(array)[2] == array[2]);
198 }
199
200 public void testLongArrayArg() {
201 long[] array = new long[]{
202 1L, 2L, 3L
203 };
204 assertTrue(longArrayParam(array)[0] == array[0]);
205 assertTrue(longArrayParam(array)[1] == array[1]);
206 assertTrue(longArrayParam(array)[2] == array[2]);
207 }
208
209 public void testIntArrayArg() {
210 int[] array = new int[]{
211 1, 2, 3
212 };
213 assertTrue(intArrayParam(array)[0] == array[0]);
214 assertTrue(intArrayParam(array)[1] == array[1]);
215 assertTrue(intArrayParam(array)[2] == array[2]);
216 }
217
218 public void testFloatArrayArg() {
219 float[] array = new float[]{
220 1.1F, 2.1F, 3.1F
221 };
222 assertTrue(floatArrayParam(array)[0] == array[0]);
223 assertTrue(floatArrayParam(array)[1] == array[1]);
224 assertTrue(floatArrayParam(array)[2] == array[2]);
225 }
226
227 public void testVariousArguments1() {
228 assertEquals(
229 "dummy".hashCode() + 1 + (int) 2.3F,
230 this.hashCode() + (int) 34L,
231 variousParams1("dummy", 1, 2.3F, this, 34L)
232 );
233 }
234
235 public void testVariousArguments2() {
236 assertEquals(
237 (int) 2.3F
238 + 1
239 + "dummy".hashCode()
240 + this.hashCode()
241 + (int) 34L
242 + "test".hashCode(), variousParams2(2.3F, 1, "dummy", this, 34L, "test")
243 );
244 }
245
246 public void testVariousArguments4() {
247 assertEquals(
248 "dummy", takesArrayAsArgument(
249 new String []{
250 "dummy", "test"
251 }
252 )[0]
253 );
254 assertEquals(
255 "test", takesArrayAsArgument(
256 new String []{
257 "dummy", "test"
258 }
259 )[1]
260 );
261 }
262
263 public static void main(String [] args) {
264 junit.textui.TestRunner.run(suite());
265 }
266
267 public static junit.framework.Test suite() {
268 return new junit.framework.TestSuite(StaticMethodAdviceTest.class);
269 }
270
271 public static void log(final String wasHere) {
273 m_logString += wasHere;
274 }
275
276 private static void nonAdvisedMethod() {
277 }
278
279 public static void methodAdvicedMethod() {
280 log("invocation ");
281 }
282
283 private static void methodAdvicedMethodNewThread() {
284 log("invocation ");
285 }
286
287 public static void multipleMethodAdvicedMethod() {
288 log("invocation ");
289 }
290
291 private static void multipleChainedMethodAdvicedMethod() {
292 log("invocation ");
293 }
294
295 public static void multipleMethodAndPrePostAdvicedMethod() {
296 log("invocation ");
297 }
298
299 public static void methodAdvicedWithPreAndPost() {
300 log("invocation ");
301 }
302
303 public static void multipleMethodAdvicedWithPreAndPost() {
304 log("invocation ");
305 }
306
307 public static void methodAdviceWithMultiplePreAndPostAdviced() {
308 log("invocation ");
309 }
310
311 private static void multiplePointcutsMethod() {
312 log("invocation ");
313 }
314
315 public static void exceptionThrower() throws Throwable {
316 throw new UnsupportedOperationException ("this is a test");
317 }
318
319 public static String joinPointMetaData(String param) {
320 return "result";
321 }
322
323 private static void hasPointcutButNoAdvice() {
324 }
325
326 public static String postAdviced() {
327 return "test";
328 }
329
330 public static void anonymousAdviced() {
331 }
332
333 public static void throwsException() throws Exception {
334 throw new Exception ("test");
335 }
336
337 public static void throwsRuntimeException() {
338 throw new RuntimeException ("test");
339 }
340
341 public static void throwsError() {
342 throw new Error ("test");
343 }
344
345 private static void noParams() throws RuntimeException {
346 }
347
348 private static long longParam(long arg) {
349 return arg;
350 }
351
352 public static int intParam(int arg) {
353 return arg;
354 }
355
356 public static short shortParam(short arg) {
357 return arg;
358 }
359
360 public static double doubleParam(double arg) {
361 return arg;
362 }
363
364 public static float floatParam(float arg) {
365 return arg;
366 }
367
368 public static byte byteParam(byte arg) {
369 return arg;
370 }
371
372 public static boolean booleanParam(boolean arg) {
373 return arg;
374 }
375
376 private static char charParam(char arg) {
377 return arg;
378 }
379
380 private static Object objectParam(Object arg) {
381 return arg;
382 }
383
384 private static int variousParams1(String str, int i, float f, Object o, long l) throws RuntimeException {
385 return str.hashCode() + i + (int) f + o.hashCode() + (int) l;
386 }
387
388 public static int variousParams2(float f, int i, String str1, Object o, long l, String str2)
389 throws RuntimeException {
390 return (int) f + i + str1.hashCode() + o.hashCode() + (int) l + str2.hashCode();
391 }
392
393 public static float variousParams3(String s, long y, String t, String r, String e, int w, String q) {
394 return 2.5F;
395 }
396
397 public static String [] takesArrayAsArgument(String [] arr) {
398 return arr;
399 }
400
401 public short[] shortArrayParam(short[] arg) {
402 return arg;
403 }
404
405 public boolean[] booleanArrayParam(boolean[] arg) {
406 return arg;
407 }
408
409 public byte[] byteArrayParam(byte[] arg) {
410 return arg;
411 }
412
413 public long[] longArrayParam(long[] arg) {
414 return arg;
415 }
416
417 public float[] floatArrayParam(float[] arg) {
418 return arg;
419 }
420
421 public char[] charArrayParam(char[] arg) {
422 return arg;
423 }
424
425 public int[] intArrayParam(int[] arg) {
426 return arg;
427 }
428
429 public static void getVoid() throws RuntimeException {
430 }
431
432 public static long getLong() throws RuntimeException {
433 return 1L;
434 }
435
436 public static int getInt() throws RuntimeException {
437 return 1;
438 }
439
440 public static short getShort() throws RuntimeException {
441 return 1;
442 }
443
444 private static double getDouble() throws RuntimeException {
445 return 1.1D;
446 }
447
448 public static float getFloat() throws RuntimeException {
449 return 1.1F;
450 }
451
452 public static byte getByte() throws RuntimeException {
453 return Byte.parseByte("1");
454 }
455
456 public static char getChar() throws RuntimeException {
457 return 'A';
458 }
459
460 private static boolean getBoolean() throws RuntimeException {
461 return true;
462 }
463
464 private static long getPrimitiveAndNullFromAdvice() throws RuntimeException {
465 return 123456789L;
466 }
467 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.