001: /**
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */package org.apache.geronimo.kernel;
017:
018: import java.net.URL;
019: import java.net.URLClassLoader;
020: import java.util.Set;
021:
022: import junit.extensions.TestSetup;
023: import junit.framework.Test;
024: import junit.framework.TestCase;
025: import junit.framework.TestSuite;
026:
027: import org.apache.geronimo.gbean.AbstractName;
028: import org.apache.geronimo.gbean.AbstractNameQuery;
029: import org.apache.geronimo.gbean.GBeanData;
030: import org.apache.geronimo.gbean.GBeanInfo;
031: import org.apache.geronimo.gbean.GBeanInfoBuilder;
032: import org.apache.geronimo.kernel.management.State;
033: import org.apache.geronimo.kernel.proxy.ProxyFactory;
034: import org.apache.geronimo.kernel.proxy.ProxyManager;
035: import org.apache.geronimo.kernel.repository.Artifact;
036:
037: /**
038: * @version $Rev:386515 $ $Date: 2006-11-16 20:35:17 -0800 (Thu, 16 Nov 2006) $
039: */
040: public class GBeanTest extends TestCase {
041: private static KernelWraper kernelWraper = new KernelWraper();
042: private Kernel realKernel;
043: private Kernel kernel;
044:
045: /**
046: * Test with plain unwrapped kernel
047: */
048: private static class KernelWraper {
049: public Kernel wrap(Kernel kernel) {
050: return kernel;
051: }
052: }
053:
054: /**
055: * Test with kernel wrapped in KernelGBean
056: */
057: private static class GBeanKernelLifecycle extends KernelWraper {
058: public Kernel wrap(Kernel kernel) {
059: return new KernelGBean(kernel);
060: }
061: }
062:
063: public static Test suite() throws Exception {
064: TestSuite suite = new TestSuite();
065: TestSuite inner = new TestSuite(GBeanTest.class);
066:
067: suite.addTest(new TestSetup(inner) {
068: protected void setUp() throws Exception {
069: super .setUp();
070: kernelWraper = new KernelWraper();
071: }
072: });
073:
074: suite.addTest(new TestSetup(inner) {
075: protected void setUp() throws Exception {
076: super .setUp();
077: kernelWraper = new GBeanKernelLifecycle();
078: }
079: });
080:
081: return suite;
082: }
083:
084: public void testListGBeans() throws Exception {
085: GBeanData gbean = buildGBeanData("name", "test", MockGBean
086: .getGBeanInfo());
087:
088: kernel.loadGBean(gbean, getClass().getClassLoader());
089: kernel.startGBean(gbean.getAbstractName());
090: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean
091: .getAbstractName()));
092:
093: Set gbeans = kernel.listGBeans(new AbstractNameQuery(gbean
094: .getAbstractName(), gbean.getGBeanInfo()
095: .getInterfaces()));
096: assertEquals(1, gbeans.size());
097: assertEquals(gbean.getAbstractName(), gbeans.iterator().next());
098: }
099:
100: public void testLifeCycle() throws Exception {
101: GBeanData gbean = buildGBeanData("name", "test", MockGBean
102: .getGBeanInfo());
103: gbean.setAttribute("finalInt", new Integer(123));
104:
105: // abstract name
106: assertFalse(kernel.isLoaded(gbean.getAbstractName()));
107: assertFalse(kernel.isRunning(gbean.getAbstractName()));
108:
109: kernel.loadGBean(gbean, getClass().getClassLoader());
110: assertTrue(kernel.isLoaded(gbean.getAbstractName()));
111: assertFalse(kernel.isRunning(gbean.getAbstractName()));
112:
113: kernel.startGBean(gbean.getAbstractName());
114: assertTrue(kernel.isLoaded(gbean.getAbstractName()));
115: assertTrue(kernel.isRunning(gbean.getAbstractName()));
116:
117: kernel.stopGBean(gbean.getAbstractName());
118: assertTrue(kernel.isLoaded(gbean.getAbstractName()));
119: assertFalse(kernel.isRunning(gbean.getAbstractName()));
120:
121: kernel.unloadGBean(gbean.getAbstractName());
122: assertFalse(kernel.isLoaded(gbean.getAbstractName()));
123: assertFalse(kernel.isRunning(gbean.getAbstractName()));
124:
125: // short name
126: assertFalse(kernel.isLoaded("name"));
127: assertFalse(kernel.isRunning("name"));
128:
129: kernel.loadGBean(gbean, getClass().getClassLoader());
130: assertTrue(kernel.isLoaded("name"));
131: assertFalse(kernel.isRunning("name"));
132:
133: kernel.startGBean("name");
134: assertTrue(kernel.isLoaded("name"));
135: assertTrue(kernel.isRunning("name"));
136:
137: kernel.stopGBean("name");
138: assertTrue(kernel.isLoaded("name"));
139: assertFalse(kernel.isRunning("name"));
140:
141: kernel.unloadGBean("name");
142: assertFalse(kernel.isLoaded("name"));
143: assertFalse(kernel.isRunning("name"));
144:
145: // type
146: assertFalse(kernel.isLoaded(MockGBean.class));
147: assertFalse(kernel.isRunning(MockGBean.class));
148:
149: kernel.loadGBean(gbean, getClass().getClassLoader());
150: assertTrue(kernel.isLoaded(MockGBean.class));
151: assertFalse(kernel.isRunning(MockGBean.class));
152:
153: kernel.startGBean(MockGBean.class);
154: assertTrue(kernel.isLoaded(MockGBean.class));
155: assertTrue(kernel.isRunning(MockGBean.class));
156:
157: kernel.stopGBean(MockGBean.class);
158: assertTrue(kernel.isLoaded(MockGBean.class));
159: assertFalse(kernel.isRunning(MockGBean.class));
160:
161: kernel.unloadGBean(MockGBean.class);
162: assertFalse(kernel.isLoaded(MockGBean.class));
163: assertFalse(kernel.isRunning(MockGBean.class));
164:
165: // short name and type
166: assertFalse(kernel.isLoaded("name", MockGBean.class));
167: assertFalse(kernel.isRunning("name", MockGBean.class));
168:
169: kernel.loadGBean(gbean, getClass().getClassLoader());
170: assertTrue(kernel.isLoaded("name", MockGBean.class));
171: assertFalse(kernel.isRunning("name", MockGBean.class));
172:
173: kernel.startGBean("name", MockGBean.class);
174: assertTrue(kernel.isLoaded("name", MockGBean.class));
175: assertTrue(kernel.isRunning("name", MockGBean.class));
176:
177: kernel.stopGBean("name", MockGBean.class);
178: assertTrue(kernel.isLoaded("name", MockGBean.class));
179: assertFalse(kernel.isRunning("name", MockGBean.class));
180:
181: kernel.unloadGBean("name", MockGBean.class);
182: assertFalse(kernel.isLoaded("name", MockGBean.class));
183: assertFalse(kernel.isRunning("name", MockGBean.class));
184: }
185:
186: public void testGetGBean() throws Exception {
187: GBeanData gbean = buildGBeanData("name", "test", MockGBean
188: .getGBeanInfo());
189: gbean.setAttribute("finalInt", new Integer(123));
190:
191: kernel.loadGBean(gbean, getClass().getClassLoader());
192: kernel.startGBean(gbean.getAbstractName());
193: assertTrue(kernel.isRunning(gbean.getAbstractName()));
194:
195: // abstract name
196: MockGBean mockGBean = (MockGBean) kernel.getGBean(gbean
197: .getAbstractName());
198: assertEquals(123, mockGBean.getFinalInt());
199: assertEquals(gbean.getAbstractName(), kernel
200: .getAbstractNameFor(mockGBean));
201: assertEquals("name", kernel.getShortNameFor(mockGBean));
202:
203: // short name
204: mockGBean = (MockGBean) kernel.getGBean("name");
205: assertEquals(123, mockGBean.getFinalInt());
206: assertEquals(gbean.getAbstractName(), kernel
207: .getAbstractNameFor(mockGBean));
208: assertEquals("name", kernel.getShortNameFor(mockGBean));
209:
210: // type
211: mockGBean = (MockGBean) kernel.getGBean(MockGBean.class);
212: assertEquals(123, mockGBean.getFinalInt());
213: assertEquals(gbean.getAbstractName(), kernel
214: .getAbstractNameFor(mockGBean));
215: assertEquals("name", kernel.getShortNameFor(mockGBean));
216:
217: // short name and type
218: mockGBean = (MockGBean) kernel
219: .getGBean("name", MockGBean.class);
220: assertEquals(123, mockGBean.getFinalInt());
221: assertEquals(gbean.getAbstractName(), kernel
222: .getAbstractNameFor(mockGBean));
223: assertEquals("name", kernel.getShortNameFor(mockGBean));
224: }
225:
226: public void testInvoke() throws Exception {
227: GBeanData gbean = buildGBeanData("name", "test", MockGBean
228: .getGBeanInfo());
229: String testValue = "test-value";
230: String otherValue = "other-value";
231: gbean.setAttribute("value", testValue);
232:
233: kernel.loadGBean(gbean, getClass().getClassLoader());
234: kernel.startGBean(gbean.getAbstractName());
235: assertTrue(kernel.isRunning(gbean.getAbstractName()));
236: MockGBean mockGBean = (MockGBean) kernel.getGBean(gbean
237: .getAbstractName());
238:
239: //
240: // abstract name
241: //
242:
243: // get and set on gbean
244: assertEquals(testValue, mockGBean.getValue());
245: mockGBean.setValue(otherValue);
246: assertEquals(otherValue, mockGBean.getValue());
247: mockGBean.setValue(testValue);
248:
249: // get and set with kernel
250: assertEquals(testValue, kernel.getAttribute(gbean
251: .getAbstractName(), "value"));
252: kernel.setAttribute(gbean.getAbstractName(), "value",
253: otherValue);
254: assertEquals(otherValue, kernel.getAttribute(gbean
255: .getAbstractName(), "value"));
256: kernel
257: .setAttribute(gbean.getAbstractName(), "value",
258: testValue);
259: assertEquals(testValue, kernel.getAttribute(gbean
260: .getAbstractName(), "value"));
261:
262: // invoke
263: assertEquals(testValue, mockGBean.fetchValue());
264: assertEquals(testValue, kernel.invoke(gbean.getAbstractName(),
265: "fetchValue"));
266: assertEquals(testValue, mockGBean.doSomething(testValue));
267: assertEquals(testValue, kernel.invoke(gbean.getAbstractName(),
268: "doSomething", new Object[] { testValue },
269: new String[] { String.class.getName() }));
270: assertEquals(testValue, mockGBean.getValue());
271:
272: //
273: // short name
274: //
275:
276: // get and set on gbean
277: assertEquals(testValue, mockGBean.getValue());
278: mockGBean.setValue(otherValue);
279: assertEquals(otherValue, mockGBean.getValue());
280: mockGBean.setValue(testValue);
281:
282: // get and set with kernel
283: assertEquals(testValue, kernel.getAttribute("name", "value"));
284: kernel.setAttribute("name", "value", otherValue);
285: assertEquals(otherValue, kernel.getAttribute("name", "value"));
286: kernel.setAttribute("name", "value", testValue);
287: assertEquals(testValue, kernel.getAttribute("name", "value"));
288:
289: // invoke
290: assertEquals(testValue, mockGBean.fetchValue());
291: assertEquals(testValue, kernel.invoke("name", "fetchValue"));
292: assertEquals(testValue, mockGBean.doSomething(testValue));
293: assertEquals(testValue, kernel.invoke("name", "doSomething",
294: new Object[] { testValue }, new String[] { String.class
295: .getName() }));
296: assertEquals(testValue, mockGBean.getValue());
297:
298: //
299: // type
300: //
301:
302: // get and set on gbean
303: assertEquals(testValue, mockGBean.getValue());
304: mockGBean.setValue(otherValue);
305: assertEquals(otherValue, mockGBean.getValue());
306: mockGBean.setValue(testValue);
307:
308: // get and set with kernel
309: assertEquals(testValue, kernel.getAttribute(MockGBean.class,
310: "value"));
311: kernel.setAttribute(MockGBean.class, "value", otherValue);
312: assertEquals(otherValue, kernel.getAttribute(MockGBean.class,
313: "value"));
314: kernel.setAttribute(MockGBean.class, "value", testValue);
315: assertEquals(testValue, kernel.getAttribute(MockGBean.class,
316: "value"));
317:
318: // invoke
319: assertEquals(testValue, mockGBean.fetchValue());
320: assertEquals(testValue, kernel.invoke(MockGBean.class,
321: "fetchValue"));
322: assertEquals(testValue, mockGBean.doSomething(testValue));
323: assertEquals(testValue, kernel.invoke(MockGBean.class,
324: "doSomething", new Object[] { testValue },
325: new String[] { String.class.getName() }));
326: assertEquals(testValue, mockGBean.getValue());
327:
328: //
329: // short name and type
330: //
331:
332: // get and set on gbean
333: assertEquals(testValue, mockGBean.getValue());
334: mockGBean.setValue(otherValue);
335: assertEquals(otherValue, mockGBean.getValue());
336: mockGBean.setValue(testValue);
337:
338: // get and set with kernel
339: assertEquals(testValue, kernel.getAttribute("name",
340: MockGBean.class, "value"));
341: kernel.setAttribute("name", MockGBean.class, "value",
342: otherValue);
343: assertEquals(otherValue, kernel.getAttribute("name",
344: MockGBean.class, "value"));
345: kernel
346: .setAttribute("name", MockGBean.class, "value",
347: testValue);
348: assertEquals(testValue, kernel.getAttribute("name",
349: MockGBean.class, "value"));
350:
351: // invoke
352: assertEquals(testValue, mockGBean.fetchValue());
353: assertEquals(testValue, kernel.invoke("name", MockGBean.class,
354: "fetchValue"));
355: assertEquals(testValue, mockGBean.doSomething(testValue));
356: assertEquals(testValue, kernel.invoke("name", MockGBean.class,
357: "doSomething", new Object[] { testValue },
358: new String[] { String.class.getName() }));
359: assertEquals(testValue, mockGBean.getValue());
360:
361: }
362:
363: public void testLoad() throws Exception {
364: ClassLoader cl = getClass().getClassLoader();
365: ClassLoader myCl = new URLClassLoader(new URL[0], cl);
366: GBeanData gbean = buildGBeanData("name", "test", MockGBean
367: .getGBeanInfo());
368: gbean.setAttribute("name", "Test");
369: gbean.setAttribute("finalInt", new Integer(123));
370:
371: kernel.loadGBean(gbean, myCl);
372: kernel.startGBean(gbean.getAbstractName());
373: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean
374: .getAbstractName()));
375: assertEquals("Hello", kernel.invoke(gbean.getAbstractName(),
376: "doSomething", new Object[] { "Hello" },
377: new String[] { String.class.getName() }));
378:
379: assertEquals(gbean.getAbstractName().getObjectName()
380: .getCanonicalName(), kernel.getAttribute(gbean
381: .getAbstractName(), "objectName"));
382: assertEquals(gbean.getAbstractName().getObjectName()
383: .getCanonicalName(), kernel.getAttribute(gbean
384: .getAbstractName(), "actualObjectName"));
385:
386: assertSame(myCl, kernel.getAttribute(gbean.getAbstractName(),
387: "actualClassLoader"));
388:
389: // the MockGBean implemmentation of getConfigurationClassLoader will throw an exception, but since the GBean architecture
390: // handles this directly the implementation method will never be called
391: kernel.getAttribute(gbean.getAbstractName(), "classLoader");
392:
393: assertSame(realKernel, kernel.getAttribute(gbean
394: .getAbstractName(), "kernel"));
395: assertSame(realKernel, kernel.getAttribute(gbean
396: .getAbstractName(), "actualKernel"));
397:
398: kernel.stopGBean(gbean.getAbstractName());
399: kernel.unloadGBean(gbean.getAbstractName());
400: }
401:
402: public void testEndpoint() throws Exception {
403: ClassLoader cl = MockGBean.class.getClassLoader();
404: GBeanData gbean1 = buildGBeanData("name", "test", MockGBean
405: .getGBeanInfo());
406: gbean1.setAttribute("finalInt", new Integer(123));
407: kernel.loadGBean(gbean1, cl);
408: kernel.startGBean(gbean1.getAbstractName());
409:
410: GBeanData gbean2 = buildGBeanData("name", "test2", MockGBean
411: .getGBeanInfo());
412: gbean2.setAttribute("finalInt", new Integer(123));
413: gbean2.setReferencePattern("MockEndpoint", gbean1
414: .getAbstractName());
415: kernel.loadGBean(gbean2, cl);
416: kernel.startGBean(gbean2.getAbstractName());
417:
418: assertEquals("endpointCheck", kernel.invoke(gbean2
419: .getAbstractName(), "checkEndpoint", null, null));
420: }
421:
422: public void testNoProxyEndpoint() throws Exception {
423: ClassLoader cl = MockGBean.class.getClassLoader();
424: GBeanData gbean1 = buildGBeanData("name", "test", MockGBean
425: .getGBeanInfo());
426: gbean1.setAttribute("finalInt", new Integer(123));
427: kernel.loadGBean(gbean1, cl);
428: kernel.startGBean(gbean1.getAbstractName());
429:
430: GBeanData gbean2 = buildGBeanData("name", "test2", MockGBean
431: .getGBeanInfo());
432: gbean2.setAttribute("finalInt", new Integer(123));
433: gbean2.setReferencePattern("MockEndpoint", gbean1
434: .getAbstractName());
435: kernel.loadGBean(gbean2, cl);
436: kernel.startGBean(gbean2.getAbstractName());
437:
438: MockGBean mockGBean1 = (MockGBean) kernel.getGBean(gbean1
439: .getAbstractName());
440: MockGBean mockGBean2 = (MockGBean) kernel.getGBean(gbean2
441: .getAbstractName());
442: // this can only be tested if no proxy is on
443: // assertSame(mockGBean2.getMockEndpoint(), mockGBean1);
444: }
445:
446: public void testProxiesInterfaces() throws Exception {
447: ClassLoader cl = getClass().getClassLoader();
448: ClassLoader myCl = new URLClassLoader(new URL[0], cl);
449: GBeanData gbean = buildGBeanData("name", "test", MockGBean
450: .getGBeanInfo());
451: gbean.setAttribute("name", "Test");
452: gbean.setAttribute("finalInt", new Integer(123));
453: kernel.loadGBean(gbean, myCl);
454: kernel.startGBean(gbean.getAbstractName());
455: ProxyManager mgr = kernel.getProxyManager();
456:
457: Object test = mgr.createProxy(gbean.getAbstractName(), myCl);
458: assertTrue(test instanceof MockEndpoint);
459: assertTrue(test instanceof MockParentInterface1);
460: assertTrue(test instanceof MockParentInterface2);
461: assertTrue(test instanceof MockChildInterface1);
462: assertTrue(test instanceof MockChildInterface2);
463: assertFalse(test instanceof Comparable);
464: ((MockEndpoint) test).doNothing();
465: assertEquals("Foo", ((MockEndpoint) test).echo("Foo"));
466: ((MockParentInterface1) test).setValue("Foo");
467: assertEquals("Foo", ((MockParentInterface1) test).getValue());
468: ((MockParentInterface1) test).setMutableInt(6);
469: assertEquals(6, ((MockParentInterface1) test).getMutableInt());
470: ((MockParentInterface2) test).doNothing();
471: assertEquals("Foo", ((MockParentInterface2) test).echo("Foo"));
472: ((MockParentInterface2) test).setValue("Foo");
473: assertEquals("Foo", ((MockParentInterface2) test).getValue());
474: ((MockChildInterface1) test).getFinalInt();
475: ((MockChildInterface2) test).doNothing();
476: assertEquals("Foo", ((MockChildInterface2) test)
477: .doSomething("Foo"));
478:
479: test = mgr.createProxy(gbean.getAbstractName(),
480: MockEndpoint.class);
481: assertTrue(test instanceof MockEndpoint);
482: assertTrue(test instanceof MockParentInterface1);
483: assertTrue(test instanceof MockParentInterface2);
484: assertTrue(test instanceof MockChildInterface1);
485: assertTrue(test instanceof MockChildInterface2);
486: assertFalse(test instanceof Comparable);
487:
488: ProxyFactory proxyFactory;
489: proxyFactory = mgr.createProxyFactory(new Class[] {
490: MockEndpoint.class, MockParentInterface2.class,
491: MockChildInterface2.class }, myCl);
492: test = proxyFactory.createProxy(gbean.getAbstractName());
493: assertTrue(test instanceof MockEndpoint);
494: assertTrue(test instanceof MockParentInterface1);
495: assertTrue(test instanceof MockParentInterface2);
496: assertTrue(test instanceof MockChildInterface1);
497: assertTrue(test instanceof MockChildInterface2);
498: assertFalse(test instanceof Comparable);
499:
500: proxyFactory = mgr.createProxyFactory(new Class[] {
501: MockEndpoint.class, MockParentInterface1.class,
502: MockChildInterface1.class }, myCl);
503: test = proxyFactory.createProxy(gbean.getAbstractName());
504: assertTrue(test instanceof MockEndpoint);
505: assertTrue(test instanceof MockParentInterface1);
506: assertFalse(test instanceof MockParentInterface2);
507: assertTrue(test instanceof MockChildInterface1);
508: assertFalse(test instanceof MockChildInterface2);
509: assertFalse(test instanceof Comparable);
510:
511: proxyFactory = mgr.createProxyFactory(new Class[] {
512: MockEndpoint.class, MockParentInterface1.class,
513: MockChildInterface1.class, Comparable.class }, myCl);
514: test = proxyFactory.createProxy(gbean.getAbstractName());
515: assertTrue(test instanceof MockEndpoint);
516: assertTrue(test instanceof MockParentInterface1);
517: assertFalse(test instanceof MockParentInterface2);
518: assertTrue(test instanceof MockChildInterface1);
519: assertFalse(test instanceof MockChildInterface2);
520:
521: proxyFactory = mgr.createProxyFactory(new Class[] {
522: MockParentInterface1.class, MockChildInterface1.class,
523: Comparable.class }, myCl);
524: test = proxyFactory.createProxy(gbean.getAbstractName());
525: assertFalse(test instanceof MockEndpoint);
526: assertTrue(test instanceof MockParentInterface1);
527: assertFalse(test instanceof MockParentInterface2);
528: assertTrue(test instanceof MockChildInterface1);
529: assertFalse(test instanceof MockChildInterface2);
530:
531: proxyFactory = mgr.createProxyFactory(new Class[] {
532: MockEndpoint.class, Comparable.class }, myCl);
533: test = proxyFactory.createProxy(gbean.getAbstractName());
534: assertTrue(test instanceof MockEndpoint);
535: assertFalse(test instanceof MockParentInterface1);
536: assertFalse(test instanceof MockParentInterface2);
537: assertFalse(test instanceof MockChildInterface1);
538: assertFalse(test instanceof MockChildInterface2);
539:
540: proxyFactory = mgr.createProxyFactory(
541: new Class[] { Comparable.class }, myCl);
542: test = proxyFactory.createProxy(gbean.getAbstractName());
543:
544: try {
545: proxyFactory = mgr.createProxyFactory(null, myCl);
546: fail();
547: } catch (NullPointerException e) {
548: }
549:
550: try {
551: proxyFactory = mgr.createProxyFactory(new Class[0], myCl);
552: fail();
553: } catch (IllegalArgumentException e) {
554: }
555:
556: try {
557: // two non-assibnable classes
558: test = mgr.createProxyFactory(
559: new Class[] { MockGBean.class, String.class }, cl)
560: .createProxy(gbean.getAbstractName());
561: fail();
562: } catch (IllegalArgumentException e) {
563: }
564: }
565:
566: public void testProxyClass() throws Exception {
567: ClassLoader cl = getClass().getClassLoader();
568: ClassLoader myCl = new URLClassLoader(new URL[0], cl);
569:
570: GBeanData gbean = buildGBeanData("name", "test", ClassGBean
571: .getGBeanInfo());
572: gbean.setAttribute("name", "Test");
573: kernel.loadGBean(gbean, myCl);
574: kernel.startGBean(gbean.getAbstractName());
575: ProxyManager mgr = kernel.getProxyManager();
576:
577: Object test = mgr.createProxy(gbean.getAbstractName(),
578: Named.class);
579: assertTrue(test instanceof Named);
580: assertFalse(test instanceof ClassGBean);
581: assertEquals("Test", ((Named) test).getName());
582:
583: test = mgr.createProxy(gbean.getAbstractName(), myCl);
584: assertTrue(test instanceof Named);
585: assertFalse(test instanceof ClassGBean);
586: assertEquals("Test", ((Named) test).getName());
587:
588: try {
589: mgr.createProxy(gbean.getAbstractName(), ClassGBean.class);
590: fail("expected an IllegalArgumentException");
591: } catch (IllegalArgumentException ignored) {
592: // expected
593: }
594: }
595:
596: protected void setUp() throws Exception {
597: super .setUp();
598: realKernel = KernelFactory.newInstance().createKernel("test");
599: realKernel.boot();
600: kernel = kernelWraper.wrap(realKernel);
601: }
602:
603: protected void tearDown() throws Exception {
604: realKernel.shutdown();
605: realKernel = null;
606: kernel = null;
607: super .tearDown();
608: }
609:
610: private GBeanData buildGBeanData(String name, String type,
611: GBeanInfo info) {
612: AbstractName abstractName = kernel.getNaming().createRootName(
613: new Artifact("test", "foo", "1", "car"), name, type);
614: return new GBeanData(abstractName, info);
615: }
616:
617: public static interface Named {
618: String getName();
619: }
620:
621: public static class ClassGBean implements Named {
622: private final String name;
623:
624: public ClassGBean(String name) {
625: this .name = name;
626: }
627:
628: public String getName() {
629: return name;
630: }
631:
632: private static final GBeanInfo GBEAN_INFO;
633:
634: static {
635: GBeanInfoBuilder infoFactory = GBeanInfoBuilder
636: .createStatic(ClassGBean.class);
637: infoFactory.setConstructor(new String[] { "name" });
638:
639: GBEAN_INFO = infoFactory.getBeanInfo();
640: }
641:
642: public static GBeanInfo getGBeanInfo() {
643: return GBEAN_INFO;
644: }
645: }
646: }
|