|
1
9 package org.jboss.portal.test.portal.kernel;
10
11 import org.jboss.portal.server.kernel.BaseService;
12 import org.jboss.portal.server.kernel.Context;
13 import org.jboss.portal.server.kernel.KernelException;
14 import org.jboss.portal.server.kernel.ServiceAlreadyRegisteredException;
15 import org.jboss.portal.server.kernel.ServiceID;
16 import org.jboss.portal.server.kernel.ServiceImplementation;
17 import org.jboss.portal.server.kernel.ServiceRegistrationException;
18 import org.jboss.portal.server.kernel.ServiceUnregistrationException;
19 import org.jboss.portal.server.kernel.UnknownServiceException;
20 import org.jboss.portal.server.kernel.state.State;
21
22
26 public class RegistrationTestCase extends KernelTestCase
27 {
28 public RegistrationTestCase(String  s)
29 {
30 super(s);
31 }
32
33 public void testRegistration() throws KernelException
34 {
35 final boolean[] registerCalled = new boolean[]{false};
36 BaseService service = new BaseService()
37 {
38 public void registered(Context ctx)
39 {
40 registerCalled[0] = true;
41 }
42 };
43 kernel.register(FOO_ID, service);
44 assertTrue(registerCalled[0]);
45 assertEquals(kernel.getState(FOO_ID), State.REGISTERED);
46 }
47
48 public void testDuplicateRegistration() throws KernelException
49 {
50 kernel.register(FOO_ID, new BaseService());
51 try
52 {
53 kernel.register(FOO_ID, new BaseService());
54 fail("A service has been addIDependOn twice");
55 }
56 catch (ServiceAlreadyRegisteredException expecteed)
57 {
58 }
59 }
60
61 public void testRegistrationThrowingExceptionFails() throws KernelException
62 {
63 BaseService service = new BaseService()
64 {
65 public void registered(Context ctx)
66 {
67 throw new RuntimeException ();
68 }
69 };
70 try
71 {
72 kernel.register(FOO_ID, service);
73 fail("Expected a registration exception");
74 }
75 catch (ServiceRegistrationException expected)
76 {
77 assertNull(kernel.getState(FOO_ID));
78 }
79 }
80
81 public void testRegistrationCreateMissingReferences() throws KernelException
82 {
83 kernel.register(BAR_ID, new BaseService(), new ServiceID[]{FOO_ID});
84 assertEquals(kernel.getState(FOO_ID), State.UNREGISTERED);
85 }
86
87 public void testUnregistration() throws KernelException
88 {
89 final boolean[] unregisterCalled = new boolean[]{false};
90 BaseService service = new BaseService()
91 {
92 public void unregister()
93 {
94 unregisterCalled[0] = true;
95 }
96 };
97 kernel.register(FOO_ID, service);
98 kernel.unregister(FOO_ID);
99 assertTrue(unregisterCalled[0]);
100 }
101
102 public void testUnregistrationKeepReference() throws KernelException
103 {
104 kernel.register(FOO_ID, new BaseService());
105 kernel.register(BAR_ID, new BaseService(), new ServiceID[]{FOO_ID,new ServiceIDImpl("foo2")});
106 kernel.unregister(FOO_ID);
107 assertEquals(kernel.getState(FOO_ID), State.UNREGISTERED);
108 }
109
110 public void testUnregistrationRemoveReference() throws KernelException
111 {
112 kernel.register(FOO_ID, new BaseService());
113 kernel.unregister(FOO_ID);
114 assertNull(kernel.getState(FOO_ID));
115 }
116
117 public void testUnregisterThrowingAnException() throws KernelException
118 {
119 BaseService service = new BaseService()
120 {
121 public void unregister()
122 {
123 throw new RuntimeException ();
124 }
125 };
126 kernel.register(FOO_ID, service);
127 try
128 {
129 kernel.unregister(FOO_ID);
130 fail("Unregistration exception was expected");
131 }
132 catch (ServiceUnregistrationException expected)
133 {
134 assertNull(kernel.getState(FOO_ID));
135 }
136 }
137
138 public void testUnregisterOnUnknownService() throws KernelException
139 {
140 try
141 {
142 kernel.unregister(FOO_ID);
143 fail("Unknown service exception was expected");
144 }
145 catch (UnknownServiceException expected)
146 {
147 }
148 }
149
150
153 public void testClearUnusedReferences1() throws KernelException
154 {
155 kernel.register(FOO_ID, new BaseService());
156 kernel.register(BAR_ID, new BaseService(), new ServiceID[]{FOO_ID});
157 kernel.unregister(FOO_ID);
158 kernel.unregister(BAR_ID);
159 assertNull(kernel.getState(FOO_ID));
160 }
161
162
165 public void testClearUnusedReferences2() throws KernelException
166 {
167 kernel.register(FOO_ID, new BaseService());
168 kernel.register(BAR_ID, new BaseService(), new ServiceID[]{FOO_ID});
169 kernel.destroy(FOO_ID);
170 kernel.unregister(BAR_ID);
171 assertNotNull(kernel.getState(FOO_ID));
172 }
173
174
175 public void testRegisteringFailsDoesNotCreateDependency() throws KernelException
176 {
177 final boolean[] addDependsOnMeCalled = new boolean[]{false};
178 BaseService service = new BaseService()
179 {
180 public void addDependsOnMe(ServiceImplementation implementation)
181 {
182 addDependsOnMeCalled[0] = true;
183 }
184 };
185 kernel.register(FOO_ID, service);
186 BaseService service2 = new BaseService()
187 {
188 public void registered(Context ctx)
189 {
190 throw new RuntimeException ();
191 }
192 };
193 try
194 {
195 kernel.register(BAR_ID, service2, new ServiceID[]{FOO_ID});
196 }
197 catch (ServiceRegistrationException expected)
198 {
199 }
200 assertFalse(addDependsOnMeCalled[0]);
201 }
202 }
203 |
Popular Tags |
Java API By Example, From Geeks To Geeks.