1
2 package eu.simuline.testhelpers;
3
4
5
6
7
8 import static org.junit.Assert.assertEquals;
9
10
11
12
13 import org.junit.Test;
14
15 import org.junit.runner.RunWith;
16 import org.junit.runners.Suite;
17 import org.junit.runners.Suite.SuiteClasses;
18
19
20
21
22
23
24
25
26 @RunWith(Suite.class)
27 @SuiteClasses({AccessorTest.TestAll.class})
28 public class AccessorTest {
29
30
31
32
33
34 static AccessorTest TEST = new AccessorTest();
35
36 public static class TestAll {
37 @Test public void testGetField() throws Exception {
38 AccessorTest.TEST.testGetField();
39 }
40 @Test public void testSetField() throws Exception {
41 AccessorTest.TEST.testSetField();
42 }
43 @Test public void testCreate() throws Exception {
44 AccessorTest.TEST.testCreate();
45 }
46 @Test public void testInvoke() throws Exception {
47 AccessorTest.TEST.testInvoke();
48 }
49 @Test public void testGetInnerClass() {
50 AccessorTest.TEST.testGetInnerClass();
51 }
52 }
53
54
55
56
57
58
59
60
61 Integer test = Integer.valueOf(0);
62
63 class NonStatic {
64 class NonStatic1 {
65 }
66
67 }
68
69 static class Static {
70 static class Static2 {
71 }
72 }
73
74 static class ForTests {
75 private int aPrimitiveField = 3;
76 private static int aStaticPrimitiveField = 4;
77 private final static int aFinalField = -1;
78
79
80 public static int getFinalFieldDummy() {
81 return aFinalField;
82 }
83 static {
84 System.out.println("ForTests:static");
85 }
86
87 private int privateMethod(int i) {
88 return aPrimitiveField*i;
89 }
90
91 public int privateMethodP(int i) {
92 return privateMethod(i);
93 }
94
95 protected int protectedMethod(int i) {
96 return aPrimitiveField*i*10;
97 }
98 private static int privateStaticMethod(int i) {
99 return aStaticPrimitiveField*i;
100 }
101
102
103 public int privateStaticMethodP(int i) {
104 return privateStaticMethod(i);
105 }
106
107 }
108
109 static class ForTestsB extends ForTests {
110 private int aPrimitiveField = 33;
111 private static int aStaticPrimitiveField = 43;
112 static {
113 System.out.println("ForTestsB:static");
114 }
115
116 private int privateMethod(int i) {
117 return aPrimitiveField*i;
118 }
119
120 public int privateMethodP(int i) {
121 return privateMethod(i);
122 }
123 protected int protectedMethod(int i) {
124 return aPrimitiveField*i*10;
125 }
126 private static int privateStaticMethod(int i) {
127 return aStaticPrimitiveField*i;
128 }
129
130 public int privateStaticMethodP(int i) {
131 return privateStaticMethod(i);
132 }
133 }
134
135
136
137
138 private void setUp() {
139 try {
140 Class.forName("eu.simuline.testhelpers.AccessorTest");
141 Class.forName("eu.simuline.testhelpers.AccessorTest.Static");
142 Class.forName("eu.simuline.testhelpers.AccessorTest.Static.Static2");
143 Class.forName("eu.simuline.testhelpers.AccessorTest.ForTests");
144 Class.forName("eu.simuline.testhelpers.AccessorTest.ForTestsB");
145 } catch (ClassNotFoundException e) {
146 throw new IllegalStateException("****");
147 }
148 }
149
150
151 public void testGetField() throws Exception {
152 Object obj;
153
154
155
156
157
158 obj = new ForTests();
159 assertEquals(Integer.valueOf(3),
160 (Integer)Accessor.getField(obj,"aPrimitiveField"));
161
162
163
164
165
166
167 try {
168 Accessor.getField((Object)null,"aPrimitiveField");
169 } catch (IllegalArgumentException e) {
170 assertEquals("Specified null-target. ",e.getMessage());
171 }
172
173
174
175
176
177
178 assertEquals(Integer.valueOf(4),
179 (Integer)Accessor.getField(ForTests.class,
180 "aStaticPrimitiveField"));
181
182
183
184
185
186
187 try {
188 Accessor.getField((Class<?>)null,"aStaticPrimitiveField");
189 } catch (IllegalArgumentException e) {
190 assertEquals("Specified null-class. ",e.getMessage());
191 }
192
193
194
195
196
197
198 try {
199 Accessor.getField(null,null,"aStaticPrimitiveField");
200 } catch (IllegalArgumentException e) {
201 assertEquals("Specified null-class. ",e.getMessage());
202 }
203
204
205
206
207
208
209 assertEquals(Integer.valueOf(3),
210 (Integer)Accessor.getField(ForTests.class,
211 new ForTestsB(),
212 "aPrimitiveField"));
213
214
215
216
217
218 assertEquals(Integer.valueOf(33),
219 (Integer)Accessor.getField(ForTestsB.class,
220 new ForTestsB(),
221 "aPrimitiveField"));
222
223
224
225
226
227 assertEquals(Integer.valueOf(4),
228 (Integer)Accessor.getField(ForTests.class,
229 null,
230 "aStaticPrimitiveField"));
231
232
233
234
235
236 assertEquals(Integer.valueOf(43),
237 (Integer)Accessor.getField(ForTestsB.class,
238 null,
239 "aStaticPrimitiveField"));
240
241
242
243
244
245
246
247
248
249
250
251
252
253 try {
254 Accessor.getField(Integer.class,null,"aNonExistingField");
255 } catch (NoSuchFieldException e) {
256 assertEquals("aNonExistingField",e.getMessage());
257 }
258
259
260
261
262
263
264 try {
265 Accessor.getField(ForTests.class,
266 new ForTests(),
267 "aStaticPrimitiveField");
268 } catch (IllegalArgumentException e) {
269 assertEquals("The specified field 'aStaticPrimitiveField' should " +
270 "not be static. ",
271 e.getMessage());
272 }
273
274
275
276
277
278
279 try {
280 Accessor.getField(ForTests.class,
281 null,
282 "aPrimitiveField");
283 } catch (IllegalArgumentException e) {
284 assertEquals("The specified field 'aPrimitiveField' should " +
285 "be static. ",
286 e.getMessage());
287 }
288
289 }
290
291
292 public void testSetField() throws Exception {
293
294 Object obj;
295
296
297
298
299
300 obj = new ForTests();
301 Accessor.setField(obj,"aPrimitiveField",Integer.valueOf(30));
302
303 assertEquals(Integer.valueOf(30),
304 (Integer)Accessor.getField(obj,"aPrimitiveField"));
305
306
307
308
309
310
311
312 try {
313 Accessor.setField((Object)null,"aPrimitiveField",null);
314 } catch (IllegalArgumentException e) {
315 assertEquals("Specified null-target. ",e.getMessage());
316 }
317
318
319
320
321
322
323 Accessor.setField(ForTests.class,
324 "aStaticPrimitiveField",
325 Integer.valueOf(40));
326 assertEquals(Integer.valueOf(40),
327 (Integer)Accessor.getField(ForTests.class,
328 "aStaticPrimitiveField"));
329
330
331
332
333
334
335 try {
336 Accessor.setField((Class<?>)null,
337 "aStaticPrimitiveField",
338 Integer.valueOf(-1));
339 } catch (IllegalArgumentException e) {
340 assertEquals("Specified null-class. ",e.getMessage());
341 }
342
343
344
345
346
347 try {
348 Accessor.setField(null,
349 null,
350 "aStaticPrimitiveField",
351 Integer.valueOf(-1));
352 } catch (IllegalArgumentException e) {
353 assertEquals("Specified null-class. ",e.getMessage());
354 }
355
356
357
358
359
360
361 obj = new ForTestsB();
362 Accessor.setField(ForTests.class,
363 obj,
364 "aPrimitiveField",
365 Integer.valueOf(30));
366 assertEquals(Integer.valueOf(30),
367 (Integer)Accessor.getField(ForTests.class,
368 obj,
369 "aPrimitiveField"));
370
371
372
373
374
375
376 obj = new ForTestsB();
377 Accessor.setField(ForTestsB.class,
378 obj,
379 "aPrimitiveField",
380 Integer.valueOf(330));
381 assertEquals(Integer.valueOf(330),
382 (Integer)Accessor.getField(ForTestsB.class,
383 obj,
384 "aPrimitiveField"));
385
386
387
388
389
390 Accessor.setField(ForTests.class,
391 null,
392 "aStaticPrimitiveField",
393 Integer.valueOf(40));
394 assertEquals(Integer.valueOf(40),
395 (Integer)Accessor.getField(ForTests.class,
396 null,
397 "aStaticPrimitiveField"));
398
399
400
401
402
403
404 Accessor.setField(ForTestsB.class,
405 null,
406 "aStaticPrimitiveField",
407 Integer.valueOf(430));
408 assertEquals(Integer.valueOf(430),
409 (Integer)Accessor.getField(ForTestsB.class,
410 null,
411 "aStaticPrimitiveField"));
412
413
414
415
416
417 try {
418 Accessor.setField(Integer.class,
419 null,
420 "aNonExistingField",
421 Integer.valueOf(-1));
422 } catch (NoSuchFieldException e) {
423 assertEquals("aNonExistingField",e.getMessage());
424 }
425
426
427
428
429
430
431 try {
432 Accessor.setField(ForTests.class,
433 new ForTests(),
434 "aStaticPrimitiveField",
435 Integer.valueOf(-1));
436 } catch (IllegalArgumentException e) {
437 assertEquals("The specified field 'aStaticPrimitiveField' should " +
438 "not be static. ",
439 e.getMessage());
440 }
441
442
443
444
445
446
447 try {
448 Accessor.setField(ForTests.class,
449 null,
450 "aPrimitiveField",
451 Integer.valueOf(-1));
452 } catch (IllegalArgumentException e) {
453 assertEquals("The specified field 'aPrimitiveField' should " +
454 "be static. ",
455 e.getMessage());
456 }
457
458
459
460
461
462
463 try {
464 Accessor.setField(ForTests.class,
465 "aFinalField",
466 Integer.valueOf(-1));
467 } catch (IllegalArgumentException e) {
468 assertEquals("Field 'aFinalField' in class '" +
469 ForTests.class.getName() +
470 "' is declared final and is hence not accessible. ",
471 e.getMessage());
472 }
473
474
475
476
477
478
479 try {
480 Accessor.setField(ForTests.class,
481 "aStaticPrimitiveField",
482 null);
483 } catch (IllegalArgumentException e) {
484 assertEquals("Tried to assign null-value " +
485 "to field 'aStaticPrimitiveField'" +
486 " in class '" + ForTests.class.getName() +
487 "' although its type '" + Integer.TYPE +
488 "' is primitive. ",
489 e.getMessage());
490 }
491
492 }
493
494 public void testCreate() throws Exception {
495
496
497
498
499
500
501 Accessor.create(ForTests.class);
502
503
504
505
506
507 Accessor.create(ForTests.class,
508 new Class[] {},
509 new Object[] {});
510 }
511
512 public void testInvoke() throws Exception {
513 int result;
514
515
516
517
518
519
520 result = ((Integer)Accessor.invoke(new ForTestsB(),
521 "privateMethod",
522 Integer.valueOf(2))
523 ).intValue();
524 assertEquals(66,result);
525
526
527
528
529
530
531 result = ((Integer)Accessor.invoke(new ForTests(),
532 "privateMethod",
533 Integer.valueOf(2))
534 ).intValue();
535 assertEquals(6,result);
536
537
538
539
540
541
542 result = ((Integer)Accessor.invoke(new ForTestsB(),
543 "protectedMethod",
544 Integer.valueOf(2))
545 ).intValue();
546 assertEquals(660,result);
547
548
549
550
551
552
553 result = ((Integer)Accessor.invoke(new ForTests(),
554 "protectedMethod",
555 Integer.valueOf(2))
556 ).intValue();
557 assertEquals(60,result);
558
559
560
561
562
563
564 Accessor.setField(ForTests.class,
565 "aStaticPrimitiveField",
566 Integer.valueOf(4));
567 result = ((Integer)Accessor.invokeStatic(ForTests.class,
568 "privateStaticMethod",
569 Integer.valueOf(2))
570 ).intValue();
571 assertEquals(8,result);
572
573 }
574
575 public void testGetInnerClass() {
576
577
578
579
580
581 try {
582 Accessor.getInnerClass(null,"ForTests");
583 } catch (IllegalArgumentException e) {
584 assertEquals("Specified null-class. ",e.getMessage());
585 }
586
587
588
589
590
591
592 try {
593 Accessor.getInnerClass(AccessorTest.class,(String)null);
594 } catch (IllegalArgumentException e) {
595 assertEquals("Specified null-class-name. ",e.getMessage());
596 }
597
598
599
600
601
602
603 try {
604 Accessor.getInnerClass(AccessorTest.class,"noInnerClass");
605 } catch (IllegalArgumentException e) {
606 assertEquals("Class '" + AccessorTest.class.getName() +
607 "' has no inner class named '" + "noInnerClass" + "'. ",
608 e.getMessage());
609 }
610
611
612
613
614
615
616 assertEquals(ForTests.class,
617 Accessor.getInnerClass(AccessorTest.class,
618 "ForTests"));
619 }
620
621
622
623
624
625
626
627
628
629
630
631 public static void main(String args[]) {
632 Actions.runFromMain();
633 }
634
635 }