KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > picocontainer > gems > lifecycle > ReflectionLifecycleStrategyTestCase


1 /*****************************************************************************
2  * Copyright (C) PicoContainer Organization. All rights reserved. *
3  * ------------------------------------------------------------------------- *
4  * The software in this package is published under the terms of the BSD *
5  * style license a copy of which has been included with this distribution in *
6  * the LICENSE.txt file. *
7  *****************************************************************************/

8 package org.picocontainer.gems.lifecycle;
9
10 import org.picocontainer.ComponentMonitor;
11 import org.picocontainer.Disposable;
12 import org.picocontainer.Startable;
13
14 import org.jmock.Mock;
15 import org.jmock.MockObjectTestCase;
16 import org.jmock.core.Constraint;
17
18 import java.io.Serializable JavaDoc;
19 import java.lang.reflect.Method JavaDoc;
20
21 /**
22  * @author Paul Hammant
23  * @author Mauro Talevi
24  * @author Jörg Schaible
25  */

26 public class ReflectionLifecycleStrategyTestCase extends MockObjectTestCase {
27
28     private ReflectionLifecycleStrategy strategy;
29     private Mock componentMonitorMock;
30     
31     public void setUp(){
32         componentMonitorMock = mock(ComponentMonitor.class);
33         strategy = new ReflectionLifecycleStrategy((ComponentMonitor)componentMonitorMock.proxy());
34     }
35
36     public void testStartable(){
37         Object JavaDoc startable = mockComponent(true, false);
38         strategy.start(startable);
39         strategy.stop(startable);
40         strategy.dispose(startable);
41     }
42
43     public void testDisposable(){
44         Object JavaDoc disposable = mockComponent(false, true);
45         strategy.start(disposable);
46         strategy.stop(disposable);
47         strategy.dispose(disposable);
48     }
49
50     public void testNotStartableNorDisposable(){
51         Object JavaDoc serializable = mock(Serializable JavaDoc.class);
52         assertFalse(strategy.hasLifecycle(serializable.getClass()));
53         strategy.start(serializable);
54         strategy.stop(serializable);
55         strategy.dispose(serializable);
56     }
57     
58     public void testMonitorChanges() {
59         Mock componentMonitorMock2 = mock(ComponentMonitor.class);
60         Mock mock = mock(Disposable.class);
61         Object JavaDoc disposable = mock.proxy();
62         mock.expects(once()).method("dispose");
63         componentMonitorMock.expects(once()).method("invoking").with(method("dispose"), same(mock.proxy()));
64         componentMonitorMock.expects(once()).method("invoked").with(method("dispose"), same(mock.proxy()), ANYTHING);
65         strategy.dispose(disposable);
66         strategy.changeMonitor((ComponentMonitor)componentMonitorMock2.proxy());
67         mock.expects(once()).method("dispose");
68         componentMonitorMock2.expects(once()).method("invoking").with(method("dispose"), same(mock.proxy()));
69         componentMonitorMock2.expects(once()).method("invoked").with(method("dispose"), same(mock.proxy()), ANYTHING);
70         strategy.dispose(disposable);
71     }
72     
73     static interface MyLifecylce {
74         void start();
75         void stop();
76         void dispose();
77     }
78     
79     public void testWithDifferentTypes() {
80         Mock anotherStartableMock = mock(MyLifecylce.class);
81         anotherStartableMock.expects(once()).method("start");
82         anotherStartableMock.expects(once()).method("stop");
83         anotherStartableMock.expects(once()).method("dispose");
84         componentMonitorMock.expects(once()).method("invoking").with(method("start"), same(anotherStartableMock.proxy()));
85         componentMonitorMock.expects(once()).method("invoked").with(method("start"), same(anotherStartableMock.proxy()), ANYTHING);
86         componentMonitorMock.expects(once()).method("invoking").with(method("stop"), same(anotherStartableMock.proxy()));
87         componentMonitorMock.expects(once()).method("invoked").with(method("stop"), same(anotherStartableMock.proxy()), ANYTHING);
88         componentMonitorMock.expects(once()).method("invoking").with(method("dispose"), same(anotherStartableMock.proxy()));
89         componentMonitorMock.expects(once()).method("invoked").with(method("dispose"), same(anotherStartableMock.proxy()), ANYTHING);
90
91         Object JavaDoc startable = mockComponent(true, false);
92         strategy.start(startable);
93         strategy.stop(startable);
94         strategy.dispose(startable);
95         startable = anotherStartableMock.proxy();
96         strategy.start(startable);
97         strategy.stop(startable);
98         strategy.dispose(startable);
99     }
100     
101     private Object JavaDoc mockComponent(boolean startable, boolean disposable) {
102         Mock mock = mock(Serializable JavaDoc.class);
103         if ( startable ) {
104             mock = mock(Startable.class);
105             mock.expects(atLeastOnce()).method("start");
106             mock.expects(atLeastOnce()).method("stop");
107             componentMonitorMock.expects(once()).method("invoking").with(method("start"), same(mock.proxy()));
108             componentMonitorMock.expects(once()).method("invoked").with(method("start"), same(mock.proxy()), ANYTHING);
109             componentMonitorMock.expects(once()).method("invoking").with(method("stop"), same(mock.proxy()));
110             componentMonitorMock.expects(once()).method("invoked").with(method("stop"), same(mock.proxy()), ANYTHING);
111         }
112         if ( disposable ) {
113             mock = mock(Disposable.class);
114             mock.expects(atLeastOnce()).method("dispose");
115             componentMonitorMock.expects(once()).method("invoking").with(method("dispose"), same(mock.proxy()));
116             componentMonitorMock.expects(once()).method("invoked").with(method("dispose"), same(mock.proxy()), ANYTHING);
117         }
118         return mock.proxy();
119     }
120     
121     MethodNameIsEqual method(String JavaDoc name) {
122         return new MethodNameIsEqual(name);
123     }
124     
125     static class MethodNameIsEqual implements Constraint {
126
127         private final String JavaDoc name;
128
129         public MethodNameIsEqual(String JavaDoc name) {
130             this.name = name;
131         }
132         
133         public boolean eval(Object JavaDoc o) {
134             return o instanceof Method JavaDoc && ((Method JavaDoc)o).getName().equals(name);
135         }
136
137         public StringBuffer JavaDoc describeTo(StringBuffer JavaDoc buffer) {
138             buffer.append("a method with name <");
139             buffer.append(name);
140             return buffer.append('>');
141         }
142         
143     }
144 }
145
Popular Tags