|
1
7 package tests.jfun.yan;
8
9 import java.util.ArrayList  ;
10 import java.util.HashMap ;
11 import java.util.LinkedHashMap ;
12
13 import tests.jfun.yan.tck.BaseContainerTestCase;
14 import tests.jfun.yan.tck.BaseContainerTestCase.Person;
15 import tests.jfun.yan.testmodel.ICacheFactory;
16 import tests.jfun.yan.testmodel.ICacheFactory2;
17 import tests.jfun.yan.testmodel.MyCache;
18
19 import jfun.yan.Component;
20 import jfun.yan.Components;
21 import jfun.yan.Creator;
22 import jfun.yan.CyclicDependencyException;
23 import jfun.yan.Functions;
24 import jfun.yan.IrresolveableArgumentException;
25 import jfun.yan.Map2;
26 import jfun.yan.Monad;
27 import jfun.yan.ParameterTypeMismatchException;
28 import jfun.yan.ReturnTypeMismatchException;
29 import jfun.yan.Container;
30 import jfun.yan.TypeMismatchException;
31 import jfun.yan.util.Predicate;
32 import junit.framework.TestCase;
33 import junit.framework.TestSuite;
34
35
41 public class BaseNonSingletonContainerTestCase extends tests.jfun.yan.tck.BaseContainerTestCase {
42 public static void main(String [] args){
43 tests.jfun.yan.Utils.runTest(suite());
44 }
45 private static TestSuite suite(){
46 return new TestSuite(BaseNonSingletonContainerTestCase.class);
47 }
48
49 public static class Avenue{
50 private final int id;
51 private final String name;
52 private static int seed = 0;
53 Avenue(int id, String name){
54 this.id = id;
55 this.name = name;
56 }
57 public static Avenue instance(String name){
58 return new Avenue(++seed, name);
59 }
60
61 public int getId() {
62 return id;
63 }
64 public String getName() {
65 return name;
66 }
67 }
68 public void testHashmapComponent(){
69 final Container yan = createYanContainer();
70 final Component newAvenue = Components.static_method(Avenue.class, "instance");
71 yan.registerComponent("target", Components.hashmap(
72 new String []{"first", "second", "third"},
73 new Creator[]{newAvenue.withArgument(0, Components.value("Randolph")),
74 newAvenue.withArgument(0, Components.value("Lincoln")),
75 newAvenue.withArgument(0, Components.value("Fullerton"))}
76 )
77 );
78 assertEquals(java.util.LinkedHashMap .class, yan.verifyType(HashMap .class));
79 final HashMap hmap = (HashMap )yan.getInstanceOfType(java.util.Map .class);
80 verifyLinkedHashMap((LinkedHashMap )hmap);
81 final Component bad_hash = Components.hashmap(
82 new String []{"a","b"},
83 new Creator[]{
84 Components.useKey("a").withState("hello"),
85 Components.useState(new Predicate(){
86 public boolean isObject(Object obj){
87 return false;
88 }
89 })
90 }
91 );
92 yan.registerComponent("bad_hash", bad_hash);
93 try{
94 yan.getInstance("bad_hash");
95 fail("should have failed with UnresolvedComponentException");
96 }
97 catch(jfun.yan.UnresolvedComponentException e){
98 assertTraceSize(e,3);
99 assertEntry(e, 0, "useKey <a>");
100 assertEntry(e, 1, bad_hash);
101 assertEntry(e, 2, "getInstance <bad_hash>");
102 }
103 }
104 public void testHashMapComponentWithLessKey(){
105 final Container yan = createYanContainer();
106 final Component newAvenue = Components.static_method(Avenue.class, "instance");
107 try{
108 yan.registerComponent("target", Components.hashmap(
109 new String []{"first", "second"},
110 new Creator[]{newAvenue.withArgument(0, Components.value("Randolph")),
111 newAvenue.withArgument(0, Components.value("Lincoln")),
112 newAvenue.withArgument(0, Components.value("Fullerton"))}
113 )
114 );
115 fail("should have failed");
116 }
117 catch(IllegalArgumentException e){
118 assertEquals("keys.length==2, vals.length==3", e.getMessage());
119 }
120 }
121 public void testHashMapComponentWithDuplicateKey(){
122 final Container yan = createYanContainer();
125 final Component newAvenue = Components.static_method(Avenue.class, "instance");
126 yan.registerComponent("target", Components.hashmap(
128 new String []{"first", "second", "second"},
129 new Creator[]{newAvenue.withArgument(0, Components.value("Randolph")),
130 newAvenue.withArgument(0, Components.value("Lincoln")),
131 newAvenue.withArgument(0, Components.value("Fullerton"))}
132 )
133 );
134 }
140 public void testCreateLinkedHashMapUsingMap(){
141 final Container yan = createYanContainer();
142 final Component newAvenue = Components.useKey("factory");
143 final Component factory = Components.static_method(Avenue.class, "instance")
144 .incomplete();
145 final String [] keys = new String []{"first", "second", "third"};
146 final Component vals = Components.array(new Component[]{newAvenue.withArgument(0, Components.value("Randolph")),
147 newAvenue.withArgument(0, Components.value("Lincoln")),
148 newAvenue.withArgument(0, Components.value("Fullerton"))});
149 final Component cc = vals.map(new jfun.yan.Map(){
150 public Object map(Object obj){
151 final Object [] vs = (Object [])obj;
152 final LinkedHashMap lhm = new LinkedHashMap (vs.length);
153 for(int i=0; i<vs.length; i++){
154 lhm.put(keys[i], vs[i]);
155 }
156 return lhm;
157 }
158 }).cast(LinkedHashMap .class);
159 yan.registerComponent(cc);
160 yan.registerComponent("factory", factory);
161 yan.verify();
162 final LinkedHashMap lhm = (LinkedHashMap )yan.getInstance(LinkedHashMap .class);
163 verifyLinkedHashMap(lhm);
164
165 }
166 public void testCreateLinkedHashMapUsingMap2(){
167 final Container yan = createYanContainer();
168 final Component newAvenue = Components.useKey("factory");
169 final Component factory = Components.static_method(Avenue.class, "instance")
170 .incomplete();
171 final Component keys = Components.value(new String []{"first", "second", "third"});
172 final Component vals = Components.list(new Creator[]{newAvenue.withArgument(0, Components.value("Randolph")),
173 newAvenue.withArgument(0, Components.value("Lincoln")),
174 newAvenue.withArgument(0, Components.value("Fullerton"))});
175 final Component cc = Monad.map(keys, vals, new Map2(){
176 public Object map(Object o1, Object o2){
177 final Object [] ks = (Object [])o1;
178 final java.util.List vs = (java.util.List )o2;
179 final LinkedHashMap lhm = new LinkedHashMap (ks.length);
180 for(int i=0;i<vs.size();i++){
181 lhm.put(ks[i], vs.get(i));
182 }
183 return lhm;
184 }
185 }).cast(LinkedHashMap .class);
186 yan.registerComponent(cc);
187 yan.registerComponent("factory", factory);
188 yan.verify();
189 final LinkedHashMap lhm = (LinkedHashMap )yan.getInstance(LinkedHashMap .class);
190 verifyLinkedHashMap(lhm);
191 }
192 public void testCreateLinkedHashMapUsingBind(){
193 final Container yan = createYanContainer();
194 final Component newAvenue = Components.useKey("factory");
195 final Component factory = Components.static_method(Avenue.class, "instance")
196 .incomplete();
197 final Component vals = Components.list(new Creator[]{newAvenue.withArgument(0, Components.value("Randolph")),
199 newAvenue.withArgument(0, Components.value("Lincoln")),
200 newAvenue.withArgument(0, Components.value("Fullerton"))});
201 final Component cc = Monad.bind(vals, new jfun.yan.Binder(){
202 public Creator bind(Object obj){
203 final Object [] ks = new String []{"first", "second", "third"};
204 final java.util.List vs = (java.util.List )obj;
205 final LinkedHashMap lhm = new LinkedHashMap ();
206 for(int i=0; i<ks.length; i++){
207 lhm.put(ks[i], vs.get(i));
208 }
209 return Components.value(lhm);
210 }
211 }).cast(LinkedHashMap .class);
212 yan.registerComponent(cc);
213 yan.registerComponent("factory", factory);
214 yan.verify();
215 final LinkedHashMap lhm = (LinkedHashMap )yan.getInstance(LinkedHashMap .class);
216 verifyLinkedHashMap(lhm);
217 }
218 private void verifyLinkedHashMap(final LinkedHashMap lhm){
219 assertEquals(3, lhm.size());
220 java.util.Iterator it = lhm.keySet().iterator();
221 String k = (String )it.next();
222 assertEquals("first", k);
223 Avenue a = (Avenue)lhm.get(k);
224 int from = a.getId();
225 assertEquals("Randolph", a.getName());
226 k = (String )it.next();
227 assertEquals("second", k);
228 a = (Avenue)lhm.get(k);
229 assertEquals(from+1, a.getId());
230 assertEquals("Lincoln", a.getName());
231 k = (String )it.next();
232 assertEquals("third", k);
233 a = (Avenue)lhm.get(k);
234 assertEquals(from+2, a.getId());
235 assertEquals("Fullerton", a.getName());
236 }
237 public void testArrayComponent(){
238 final Container yan = createYanContainer();
239 yan.registerComponent("target",
240 Components.array(
241 new Component[]{Components.value("hello"), Components.value("world")}));
242 assertEquals(String [].class, yan.verifyComponent(
243 yan.getComponent("target")));
244 String [] arr = (String [])yan.getInstance("target");
245 assertEquals(2, arr.length);
246 assertEquals("hello", arr[0]);
247 assertEquals("world", arr[1]);
248 }
249 public void testArrayComponentWithDynamicBoundComponent(){
250 final Container yan = createYanContainer();
251 yan.registerComponent("target", Components.array(
252 new Component[]{Components.value("hello"), Components.useKey("you")}));
253 yan.registerValue("you", "world");
254 assertEquals(Object [].class, yan.verifyComponent(yan.getComponent("target")));
255 Object [] arr = (Object [])yan.getInstanceOfType(Object [].class);
256 assertEquals(2, arr.length);
257 assertEquals("hello", arr[0]);
258 assertEquals("world", arr[1]);
259 }
260 public void testArrayComponentWithComponentTypeSpecified(){
261 final Container yan = createYanContainer();
262 yan.registerComponent(
263 Components.array(
264 new Component[]{Components.value("hello"), Components.useKey("you")}
265 , CharSequence .class));
266 yan.registerValue("you", "world");
267 assertEquals(CharSequence [].class, yan.verifyComponent(yan.getComponent(CharSequence [].class)));
268 CharSequence [] arr = (CharSequence [])yan.getInstanceOfType(CharSequence [].class);
269 assertFalse(arr instanceof String []);
270 assertEquals(2, arr.length);
271 assertEquals("hello", arr[0]);
272 assertEquals("world", arr[1]);
273 }
274 public void testArrayComponentWithRaggedType(){
275 final Container yan = createYanContainer();
276 yan.registerComponent("target", Components.array(
277 new Component[]{Components.value("hello"),
278 Components.useKey("age")}));
279 yan.registerValue("age", new Integer (20));
280 assertEquals(Object [].class, yan.verifyComponent(yan.getComponent("target")));
281 Object [] arr = (Object [])yan.getInstanceOfType(Object [].class);
282
283 assertEquals(2, arr.length);
284 assertEquals("hello", arr[0]);
285 assertEquals(new Integer (20), arr[1]);
286 }
287 public void testBadArrayComponentWithRaggedType(){
288 final Container yan = createYanContainer();
289 yan.registerValue("age", new Integer (20));
290 yan.registerComponent("target", Components.array(
291 new Component[]{Components.value("hello"),
292 Components.useKey("age")}, CharSequence .class));
293
294 try{
295 yan.verify();
296 fail("should have failed with illegal argument");
297 }
298 catch(TypeMismatchException e){
299 assertEquals("type mismatch: the #1 element is of java.lang.Integer, while java.lang.CharSequence is expected.", e.getMessage());
300 }
301 }
302 public void testListComponent(){
303 final Container yan = createYanContainer();
304 yan.registerComponent(Components.list(new Creator[]{
305 Components.value("hello"), Components.value("world")}
306 ));
307 assertEquals(java.util.ArrayList .class,
308 yan.verifyComponent(yan.getComponentOfType(java.util.List .class)));
309 final java.util.List list = (java.util.List )yan.getInstanceOfType(java.util.ArrayList .class);
310 assertEquals(2, list.size());
311 assertEquals("hello", list.get(0));
312 assertEquals("world", list.get(1));
313 }
314 public void testCyclicListComponent(){
315 final Container yan = createYanContainer();
316 yan.registerComponent("target", Components.list(new Creator[]{
317 Components.value("hello"), Components.useKey("target")}
318 ));
319 try{
320 yan.verifyKey("target");
321 fail("should have failed with cyclic dependency");
322 }
323 catch(CyclicDependencyException e){
324 assertEquals(4, e.getResolutionTrace().size());
325 assertEntry(e, 0, "list [hello,useKey <target>]");
326 assertEntry(e, 1, "useKey <target>");
327 assertEntry(e, 2, "list [hello,useKey <target>]");
328 assertEntry(e, 3, "verifyKey <target>");
329 }
330 }
331 public void testCyclicArrayComponent(){
332 final Container yan = createYanContainer();
333 yan.registerComponent("target", Components.array(new Component[]{
334 Components.value("hello"), Components.useKey("target")}
335 ));
336 try{
337 yan.verifyKey("target");
338 fail("should have failed with cyclic dependency");
339 }
340 catch(CyclicDependencyException e){
341 assertTraceSize(e, 4);
342 assertEntry(e, 0, "array [hello,useKey <target>]:java.lang.Object[]");
343 assertEntry(e, 1, "useKey <target>");
344 assertEntry(e, 2, "array [hello,useKey <target>]:java.lang.Object[]");
345 assertEntry(e, 3, "verifyKey <target>");
346 }
347 }
348 public void testUseAll(){
349 final Container yan = createYanContainer();
350 yan.registerComponent("target", Components.useAll(String .class));
351 assertEquals(0, ((java.util.List )yan.getInstanceOfType(java.util.List .class)).size());
352 yan.registerValue("abc");
353 yan.registerValue("yet another", "cde");
354 java.util.List strs = (java.util.List )yan.getInstance("target");
355 assertEquals(2, strs.size());
356 assertEquals("abc", strs.get(0));
357 assertEquals("cde", strs.get(1));
358 yan.registerComponent("another", Components.useKey("yet another").subsume(String .class));
359 strs = (java.util.List )yan.getInstance("target");
360 assertEquals(3, strs.size());
361 assertEquals("abc", strs.get(0));
362 assertEquals("cde", strs.get(1));
363 assertEquals("cde", strs.get(2));
364
365 }
366 public void testUseAllInSameContainer(){
367 final Container yan = createYanContainer();
368 yan.registerComponent("target", Components.useAll(yan, String .class));
369 assertEquals(0, ((java.util.List )yan.getInstanceOfType(java.util.List .class)).size());
370 yan.registerValue("abc");
371 yan.registerValue("yet another", "cde");
372 java.util.List strs = (java.util.List )yan.getInstance("target");
373 assertEquals(2, strs.size());
374 assertEquals("abc", strs.get(0));
375 assertEquals("cde", strs.get(1));
376 yan.registerComponent("another", Components.useKey("yet another").subsume(String .class));
377 strs = (java.util.ArrayList )yan.getInstance("target");
378 assertEquals(3, strs.size());
379 assertEquals("abc", strs.get(0));
380 assertEquals("cde", strs.get(1));
381 assertEquals("cde", strs.get(2));
382
383 }
384 public void testUseAllInDifferentContainer(){
385 final Container yan1 = createYanContainer();
386 final Container yan = createYanContainer();
387 yan1.registerComponent("target", Components.useAll(yan, String .class));
388 assertEquals(0, ((java.util.List )yan1.getInstanceOfType(java.util.List .class)).size());
389 yan.registerValue("abc");
390 yan.registerValue("yet another", "cde");
391 java.util.List strs = (java.util.List )yan1.getInstance("target");
392 assertEquals(2, strs.size());
393 assertEquals("abc", strs.get(0));
394 assertEquals("cde", strs.get(1));
395 yan.registerComponent("another", Components.useKey(yan, "yet another").subsume(String .class));
397 strs = (java.util.List )yan1.getInstance("target");
398 assertEquals(3, strs.size());
399 assertEquals("abc", strs.get(0));
400 assertEquals("cde", strs.get(1));
401 assertEquals("cde", strs.get(2));
402
403 }
404 public void testUseState(){
405 final Container yan = createYanContainer();
406 yan.registerComponent("allnul", Components.useState(new Predicate(){
407 public boolean isObject(Object obj){
408 return obj==null;
409 }
410 public String toString(){return "isnull";}
411 }).withState("!do not recurse on me"));
412 yan.registerComponent("startswithhello", Components.useState(new Predicate(){
413 public boolean isObject(Object obj){
414 if(obj instanceof String ){
415 final String s = (String )obj;
416 return s.startsWith("hello");
417 }
418 else return false;
419 }
420 public String toString(){return "startsWithHello";}
421 }));
422 yan.registerValue("foo");
423 yan.registerComponent("bar", Components.value(Class .class)
424 .withState("hello world"));
425 yan.registerValue("baz", new Integer (10));
426 yan.registerComponent("joo", Components.value(int.class).withState("hello me"));
427 try{
428 final java.util.List nulls = (java.util.List )yan.getInstance("allnul");
429 final java.util.List hellos = (java.util.List )yan.getInstance("startswithhello");
430 assertEquals(3, nulls.size());
431 assertEquals(2, hellos.size());
432 final java.util.List the_hellos = (java.util.List )nulls.get(0);
433 assertEquals(hellos, the_hellos);
434 assertEquals("foo", nulls.get(1));
435 assertEquals(new Integer (10), nulls.get(2));
436 assertEquals(Class .class, hellos.get(0));
437 assertEquals(int.class, hellos.get(1));
438 }
439 catch(jfun.yan.YanException e){
440 e.printResolutionTrace(System.err);
441 throw e;
442 }
443 }
444 public String signup(Person p1, Person p2){
445 assertSame(p1, p2);
446 return p1.getName();
447 }
448 public void testSharedArgument()
449 throws Exception {
450 final Container yan = createYanContainer();
451 final Component signup = Components.method(this, "signup");
452 yan.registerComponent("target",
453 Monad.bind(Components.useType(Person.class),
454 new jfun.yan.Binder(){
455 public Creator bind(Object v){
456 final Component c = Components.value(v);
457 return signup.withArguments(
458 new Creator[]{c,c}
459 );
460 }
461 }
462 ).cast(signup.getType())
463 );
464 yan.registerComponent(Components.method(this, "newPerson").bean(new String []{"name"}));
465 yan.registerValue(new Integer (10));
466 final String name = "Jack Nicolson";
467 yan.registerValue(name);
468 assertEquals(name, yan.getInstance("target"));
469 }
470 public void testFactory(){
471 final Container yan = createYanContainer();
472 final Component mycache =
473 Components.ctor(MyCache.class,
474 new Class []{String .class, int.class});
475
476 final Component factory =
477 mycache.factory(ICacheFactory.class);
478 yan.registerComponent("target", factory);
479 final ICacheFactory ifactory =
480 (ICacheFactory)yan.getInstance("target");
481 final tests.jfun.yan.testmodel.ICache icache = ifactory.createCache("tom", 10);
482 assertEquals(MyCache.class, icache.getClass());
483 assertEquals("tom", icache.getName());
484 assertEquals(10, icache.getCapacity());
485 try{
486 yan.verify();
487 fail("should have failed with IrresolveableArgumentException");
488 }
489 catch(IrresolveableArgumentException e){
490 assertTraceSize(e, 3);
491 assertEntry(e, 1, "tests.jfun.yan.testmodel.ICacheFactory");
492 assertEquals(0, e.getOrdinalPosition());
493 assertEquals(String .class, e.getParameterType());
494 }
495 yan.registerValue("someone");
496 try{
497 yan.verify();
498 fail("should have failed with IrresolveableArgumentException");
499 }
500 catch(IrresolveableArgumentException e){
501 assertTraceSize(e, 3);
502 assertEntry(e, 1, "tests.jfun.yan.testmodel.ICacheFactory");
503 assertEquals(1, e.getOrdinalPosition());
504 assertEquals(int.class, e.getParameterType());
505 }
506 yan.registerValue(new Integer (0));
507 yan.verify();
508
509 final tests.jfun.yan.testmodel.ICache icache2 = ifactory.createCache("jack", 11);
510 assertEquals(MyCache.class, icache2.getClass());
511 assertEquals("jack", icache2.getName());
512 assertEquals(11, icache2.getCapacity());
513
514 final tests.jfun.yan.testmodel.ICache icache3 = ifactory.createCache();
515 assertEquals(MyCache.class, icache3.getClass());
516 assertEquals("someone", icache3.getName());
517 assertEquals(0, icache3.getCapacity());
518 }
519 public void testCustomizationsOnProductComponentShouldOverrideFactoryParameter(){
520 final Container yan = createYanContainer();
521 final Component mycache =
522 Components.ctor(MyCache.class,
523 new Class []{String .class, int.class})
524 .withArgument(1, Components.value(100));
525
526 final Component factory =
527 mycache.factory(ICacheFactory.class);
528 yan.registerComponent("target", factory);
529 final ICacheFactory ifactory =
530 (ICacheFactory)yan.getInstance("target");
531 final tests.jfun.yan.testmodel.ICache icache = ifactory.createCache("tom", 10);
532 assertEquals(MyCache.class, icache.getClass());
533 assertEquals("tom", icache.getName());
534 assertEquals(100, icache.getCapacity());
535 try{
536 yan.verify();
537 fail("should have failed with IrresolveableArgumentException");
538 }
539 catch(IrresolveableArgumentException e){
540 assertTraceSize(e, 4);
542 assertEntry(e, 2, "tests.jfun.yan.testmodel.ICacheFactory");
543 assertEquals(0, e.getOrdinalPosition());
544 assertEquals(String .class, e.getParameterType());
545 }
546 yan.registerValue("someone");
547 yan.verify();
548 yan.registerValue(new Integer (0));
549 yan.verify();
550
551 final tests.jfun.yan.testmodel.ICache icache2 = ifactory.createCache("jack", 11);
552 assertEquals(MyCache.class, icache2.getClass());
553 assertEquals("jack", icache2.getName());
554 assertEquals(100, icache2.getCapacity());
555
556 final tests.jfun.yan.testmodel.ICache icache3 = ifactory.createCache();
557 assertEquals(MyCache.class, icache3.getClass());
558 assertEquals("someone", icache3.getName());
559 assertEquals(100, icache3.getCapacity());
560 }
561 public void testLocalCustomizationOverridesFactoryParametersRedirectedToPropeties()
562 throws Exception {
563 final Container yan = createYanContainer();
564 final Component mycache =
565 Components.bean(MyCache.class)
566 .withProperty("name",
568 Components.useProperty(MyCache.class, "capacity", int.class)
569 .map(new jfun.yan.Map(){
570 public Object map(Object obj){
571 return obj.toString();
572 }
573 }).cast(String .class)
574 )
575 .withProperty("name", Components.value("should not see me"))
576 ;
577
578 final Component factory =
579 Components.fromArguments(mycache, new String []{"name","capacity"})
580 .factory(ICacheFactory.class);
581 yan.registerComponent("target", factory);
582 final ICacheFactory ifactory =
583 (ICacheFactory)yan.getInstance("target");
584 final tests.jfun.yan.testmodel.ICache icache = ifactory.createCache("tom", 10);
585 assertEquals(MyCache.class, icache.getClass());
586 assertEquals("10", icache.getName());
587 assertEquals(10, icache.getCapacity());
588 try{
589 yan.verify();
590 fail("should have failed with IrresolveableArgumentException");
591 }
592 catch(IrresolveableArgumentException e){
593 assertTraceSize(e, 7);
595 assertEntry(e, 5, "tests.jfun.yan.testmodel.ICacheFactory");
596 final int pos = e.getOrdinalPosition();
597 if(pos==0)
598 assertEquals(String .class, e.getParameterType());
599 else
600 assertEquals(int.class, e.getParameterType());
601 }
602 yan.registerValue("someone");
603 try{
604 yan.verify();
605 fail("should have failed with IrresolveableArgumentException");
606 }
607 catch(IrresolveableArgumentException e){
608 assertTraceSize(e, 7);
609 assertEntry(e, 5, "tests.jfun.yan.testmodel.ICacheFactory");
610 final int pos = e.getOrdinalPosition();
611 if(pos==0)
612 assertEquals(String .class, e.getParameterType());
613 else
614 assertEquals(int.class, e.getParameterType());
615 }
616 yan.registerValue(new Integer (0));
617 yan.verify();
618
619 final tests.jfun.yan.testmodel.ICache icache2 = ifactory.createCache("jack", 11);
620 assertEquals(MyCache.class, icache2.getClass());
621 assertEquals("11", icache2.getName());
622 assertEquals(11, icache2.getCapacity());
623
624 final tests.jfun.yan.testmodel.ICache icache3 = ifactory.createCache();
625 assertEquals(MyCache.class, icache3.getClass());
626 assertEquals("0", icache3.getName());
627 assertEquals(0, icache3.getCapacity());
628 }
629 public void testFactoryWithParametersRedirectedToPropeties()
630 throws Exception {
631 final Container yan = createYanContainer();
632 final Component mycache =
633 Components.bean(MyCache.class);
634
635 final Component factory =
636 Components.fromArguments(mycache, new String []{"name","capacity"})
637 .factory(ICacheFactory.class);
638 yan.registerComponent("target", factory);
639 final ICacheFactory ifactory =
640 (ICacheFactory)yan.getInstance("target");
641 final tests.jfun.yan.testmodel.ICache icache = ifactory.createCache("tom", 10);
642 assertEquals(MyCache.class, icache.getClass());
643 assertEquals("tom", icache.getName());
644 assertEquals(10, icache.getCapacity());
645 try{
646 yan.verify();
647 fail("should have failed with IrresolveableArgumentException");
648 }
649 catch(IrresolveableArgumentException e){
650 assertTraceSize(e, 5);
652 assertEntry(e, 3, "tests.jfun.yan.testmodel.ICacheFactory");
653 final int pos = e.getOrdinalPosition();
654 if(pos==0)
655 assertEquals(String .class, e.getParameterType());
656 else
657 assertEquals(int.class, e.getParameterType());
658 }
659 yan.registerValue("someone");
660 try{
661 yan.verify();
662 fail("should have failed with IrresolveableArgumentException");
663 }
664 catch(IrresolveableArgumentException e){
665 assertTraceSize(e, 5);
666 assertEntry(e, 3, "tests.jfun.yan.testmodel.ICacheFactory");
667 final int pos = e.getOrdinalPosition();
668 if(pos==0)
669 assertEquals(String .class, e.getParameterType());
670 else
671 assertEquals(int.class, e.getParameterType());
672 }
673 yan.registerValue(new Integer (0));
674 yan.verify();
675
676 final tests.jfun.yan.testmodel.ICache icache2 = ifactory.createCache("jack", 11);
677 assertEquals(MyCache.class, icache2.getClass());
678 assertEquals("jack", icache2.getName());
679 assertEquals(11, icache2.getCapacity());
680
681 final tests.jfun.yan.testmodel.ICache icache3 = ifactory.createCache();
682 assertEquals(MyCache.class, icache3.getClass());
683 assertEquals("someone", icache3.getName());
684 assertEquals(0, icache3.getCapacity());
685 }
686 public void testFactoryWithParametersRedirectedToPropertiesThenRedirectedBackToArguments()
687 throws Exception {
688 final Container yan = createYanContainer();
689 final Component mycache =
690 Components.ctor(MyCache.class, new Class []{String .class, int.class})
691 .fromProperties(new String []{"name","capacity"});
692
693 final Component factory =
694 mycache.fromArguments(new String []{"name","capacity"})
695 .factory(ICacheFactory.class);
696 yan.registerComponent("target", factory);
697 final ICacheFactory ifactory =
698 (ICacheFactory)yan.getInstance("target");
699 final tests.jfun.yan.testmodel.ICache icache = ifactory.createCache("tom", 10);
700 assertEquals(MyCache.class, icache.getClass());
701 assertEquals("tom", icache.getName());
702 assertEquals(10, icache.getCapacity());
703 try{
704 yan.verify();
705 fail("should have failed with IrresolveableArgumentException");
706 }
707 catch(IrresolveableArgumentException e){
708 assertTraceSize(e, 5);
710 assertEntry(e, 3, "tests.jfun.yan.testmodel.ICacheFactory");
711 final int pos = e.getOrdinalPosition();
712 if(pos==0)
713 assertEquals(String .class, e.getParameterType());
714 else
715 assertEquals(int.class, e.getParameterType());
716 }
717 yan.registerValue("someone");
718 try{
719 yan.verify();
720 fail("should have failed with IrresolveableArgumentException");
721 }
722 catch(IrresolveableArgumentException e){
723 assertTraceSize(e, 5);
724 assertEntry(e, 3, "tests.jfun.yan.testmodel.ICacheFactory");
725 final int pos = e.getOrdinalPosition();
726 if(pos==0)
727 assertEquals(String .class, e.getParameterType());
728 else
729 assertEquals(int.class, e.getParameterType());
730 }
731 yan.registerValue(new Integer (0));
732 yan.verify();
733
734 final tests.jfun.yan.testmodel.ICache icache2 = ifactory.createCache("jack", 11);
735 assertEquals(MyCache.class, icache2.getClass());
736 assertEquals("jack", icache2.getName());
737 assertEquals(11, icache2.getCapacity());
738
739 final tests.jfun.yan.testmodel.ICache icache3 = ifactory.createCache();
740 assertEquals(MyCache.class, icache3.getClass());
741 assertEquals("someone", icache3.getName());
742 assertEquals(0, icache3.getCapacity());
743 }
744 public void testFactoryWithBadParameterSequence()
745 throws Exception {
746 final Container yan = createYanContainer();
747 final Component mycache =
748 Components.ctor(MyCache.class,
749 new Class []{String .class, int.class});
750
751 final Component factory =
752 mycache.factory(ICacheFactory2.class);
753 yan.registerComponent("target", factory);
754 try{
755 yan.verify();
756 fail("should have failed with ParameterTypeMismatchException");
757 }
758 catch(ParameterTypeMismatchException e){
759 assertEquals(0, e.getOrdinalPosition());
760 assertEquals(String .class, e.getExpectedType());
761 assertEquals(int.class, e.getActualType());
762 }
763 }
764 public void testFactoryWithBadReturnType(){
765 final Container yan = createYanContainer();
766 final Component mycache =
767 Components.ctor(MyCache.class,
768 new Class []{String .class, int.class});
769
770 final Component factory =
771 mycache.factory(tests.jfun.yan.testmodel.IMonitoredCacheFactory.class);
772 yan.registerComponent("target", factory);
773 try{
774 yan.verify();
775 fail("should have failed with ReturnTypeMismatchException");
776 }
777 catch(ReturnTypeMismatchException e){
778 assertEquals("tests.jfun.yan.testmodel.MyCache cannot match return type of <public abstract tests.jfun.yan.testmodel.IMonitoredCache tests.jfun.yan.testmodel.IMonitoredCacheFactory.createCache(java.lang.String,int)>",
780 e.getMessage());
781 assertEntry(e, 0, "tests.jfun.yan.testmodel.IMonitoredCacheFactory");
782 assertEquals(tests.jfun.yan.testmodel.IMonitoredCache.class, e.getExpectedType());
784 assertEquals(MyCache.class, e.getActualType());
785 }
786 }
787 public void testSealedComponent(){
788 final Container yan = createYanContainer();
789 final Component c1 = Components.ctor(java.util.ArrayList .class, new Class []{int.class});
790 yan.registerComponent("list", c1.seal());
791 yan.registerValue(new Integer (10));
792 try{
793 yan.getInstance("list");
794 fail ("should have failed with IrresolveableArgumentException");
795 }
796 catch(IrresolveableArgumentException e){}
797 yan.registerComponent("list", c1.seal().withArgument(0, Components.value(5)));
798 yan.getInstance("list");
799
801 yan.registerComponent("list", c1);
802 yan.registerComponent("target", Components.useKey("list").seal()
803 .withArgument(0, Components.value(12)));
804 yan.getInstance("target");
806 yan.registerComponent("list", c1.withArgument(0,
811 Components.useArgument(Functions.ctor(
812 ArrayList .class, new Class []{int.class}), 0, int.class)));
813 yan.registerComponent("target", Components.useKey("list").seal()
814 .withArgument(0, Components.value(12)));
815 yan.getInstance("target");
817 yan.registerComponent("list", c1.withArgument(0, Components.useType(int.class)));
821 yan.registerComponent("target", Components.useKey("list").seal()
822 .withArgument(0, Components.value(12)));
823 final java.util.ArrayList result = (ArrayList )yan.getInstance("target");
824 final Component array = Components.ctor(String [].class);
825
826
827 yan.registerComponent("array", array.withArgument(0, Components.useType(int.class)));
828 yan.registerComponent("target", Components.useKey("array").seal()
829 .withArgument(0, Components.value(12)));
830 final String [] arr = (String [])yan.getInstance("target");
831 assertEquals(10, arr.length);
832 final Component array2 = Components.ctor(int[].class, new Class []{int.class});
833 yan.registerComponent("array", array2.withArgument(0, Components.useType(int.class)));
834 yan.registerComponent("target", Components.useKey("array").seal()
835 .withArgument(0, Components.value(12)));
836 final int[] arr2 = (int[])yan.getInstance("target");
837 assertEquals(10, arr2.length);
838 try{
839 Components.ctor(int[].class, null);
840 }
841 catch(IllegalArgumentException e){
842 assertEquals("constructor not found for: int[]()", e.getMessage());
843 }
844 try{
845 Components.ctor(int[].class, new Class [0]);
846 }
847 catch(IllegalArgumentException e){
848 assertEquals("constructor not found for: int[]()", e.getMessage());
849 }
850 try{
851 Components.ctor(int[].class, new Class []{int.class, int.class});
852 }
853 catch(IllegalArgumentException e){
854 assertEquals("constructor not found for: int[](int,int)", e.getMessage());
855 }
856 }
857 }
858 |
Popular Tags |
Java API By Example, From Geeks To Geeks.