2 * Copyright 2008 the original author or authors.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.wamblee.system.adapters;
18 import org.wamblee.system.core.DefaultProvidedInterface;
19 import org.wamblee.system.core.ProvidedInterface;
20 import org.wamblee.system.core.RequiredInterface;
21 import org.wamblee.system.core.RequiredInterfaceComparator;
23 import org.wamblee.test.AssertionUtils;
25 import java.lang.reflect.Method;
27 import java.util.ArrayList;
28 import java.util.Collections;
29 import java.util.Comparator;
30 import java.util.List;
32 import javax.sql.DataSource;
41 public class SetterConfigurationTest extends AdapterTestCase {
45 public void testOneSetter() {
46 SetterConfiguration config = new SetterConfiguration(X5.class);
47 config.initAllSetters();
49 List<RequiredInterface> required = config.getRequiredInterfaces();
50 assertEquals(1, required.size());
51 assertEquals("setValue.0", required.get(0).getName());
53 ProvidedInterface provided = new DefaultProvidedInterface("janse",
55 required.get(0).setProvider(provided);
56 scope.publishInterface(provided, "hello");
59 assertNull(obj.getValue());
60 config.inject(scope, obj);
61 assertEquals("hello", obj.getValue());
67 public void testPrivateSetter() {
68 SetterConfiguration config = new SetterConfiguration(X5.class);
69 config.setNonPublic(true);
70 config.initAllSetters();
72 List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
73 .getRequiredInterfaces());
74 Collections.sort(required,
75 new Comparator<RequiredInterface>() {
77 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
78 return aO1.getName().compareTo(aO2.getName());
81 assertEquals(2, required.size());
82 assertEquals("setValue.0", required.get(0).getName());
83 assertEquals("setXyz.0", required.get(1).getName());
85 ProvidedInterface providedString = new DefaultProvidedInterface("janse",
87 assertTrue(required.get(0).implementedBy(providedString));
88 required.get(0).setProvider(providedString);
89 scope.publishInterface(providedString, "hello");
91 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
93 assertTrue(required.get(1).implementedBy(providedInt));
94 required.get(1).setProvider(providedInt);
95 scope.publishInterface(providedInt, 100);
98 assertNull(obj.getValue());
99 assertNull(obj.getXyz());
100 config.inject(scope, obj);
101 assertEquals("hello", obj.getValue());
102 assertEquals(100, obj.getXyz().intValue());
108 public void testInheritance() {
109 SetterConfiguration config = new SetterConfiguration(X9.class);
110 config.setNonPublic(true);
111 config.initAllSetters();
113 List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
114 .getRequiredInterfaces());
115 Collections.sort(required,
116 new Comparator<RequiredInterface>() {
118 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
119 return aO1.getName().compareTo(aO2.getName());
122 assertEquals(3, required.size());
123 assertEquals("setFlag.0", required.get(0).getName());
124 assertEquals("setValue.0", required.get(1).getName());
125 assertEquals("setXyz.0", required.get(2).getName());
127 ProvidedInterface providedBoolean = new DefaultProvidedInterface("janse",
129 assertTrue(required.get(0).implementedBy(providedBoolean));
130 required.get(0).setProvider(providedBoolean);
131 scope.publishInterface(providedBoolean, true);
133 ProvidedInterface providedString = new DefaultProvidedInterface("janse",
135 assertTrue(required.get(1).implementedBy(providedString));
136 required.get(1).setProvider(providedString);
137 scope.publishInterface(providedString, "hello");
139 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
141 assertTrue(required.get(2).implementedBy(providedInt));
142 required.get(2).setProvider(providedInt);
143 scope.publishInterface(providedInt, 100);
146 assertNull(obj.getValue());
147 assertNull(obj.getXyz());
148 assertFalse(obj.isFlag());
149 config.inject(scope, obj);
150 assertEquals("hello", obj.getValue());
151 assertEquals(100, obj.getXyz().intValue());
152 assertTrue(obj.isFlag());
158 public void testMultipleSetters() {
159 SetterConfiguration config = new SetterConfiguration(X6.class)
161 List<RequiredInterface> required = config.getRequiredInterfaces();
162 Collections.sort(required, new RequiredInterfaceComparator());
163 assertEquals(2, required.size());
164 assertEquals("setHost.0", required.get(0).getName());
165 assertEquals("setPort.0", required.get(1).getName());
167 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
169 required.get(0).setProvider(provided0);
170 scope.publishInterface(provided0, "hello");
172 ProvidedInterface provided1 = new DefaultProvidedInterface("port",
174 required.get(1).setProvider(provided1);
175 scope.publishInterface(provided1, 10);
178 assertNull(obj.getHost());
179 assertNull(obj.getPort());
181 config.inject(scope, obj);
182 assertEquals("hello", obj.getHost());
183 assertEquals(10, obj.getPort().intValue());
189 public void testInvokeWrongType() {
190 final SetterConfiguration config = new SetterConfiguration(X5.class)
192 List<RequiredInterface> required = config.getRequiredInterfaces();
193 assertEquals(1, required.size());
194 assertEquals("setValue.0", required.get(0).getName());
196 ProvidedInterface provided = new DefaultProvidedInterface("janse",
198 required.get(0).setProvider(provided);
199 scope.publishInterface(provided, "hello");
201 final X6 obj = new X6();
202 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
204 public void run() throws Exception {
205 config.inject(scope, obj);
207 }, IllegalArgumentException.class);
213 public void testSetExplicitValue() {
214 SetterConfiguration config = new SetterConfiguration(X5.class)
216 config.values("setValue").setValue(0, "bladibla");
218 List<RequiredInterface> required = config.getRequiredInterfaces();
219 assertEquals(0, required.size());
222 assertNull(obj.getValue());
223 config.inject(scope, obj);
224 assertEquals("bladibla", obj.getValue());
230 public void testClear() {
231 SetterConfiguration config = new SetterConfiguration(X6.class);
234 List<RequiredInterface> required = config.getRequiredInterfaces();
235 Collections.sort(required, new RequiredInterfaceComparator());
236 assertEquals(0, required.size());
239 assertNull(obj.getHost());
240 assertNull(obj.getPort());
242 config.inject(scope, obj);
244 assertNull(obj.getHost());
245 assertNull(obj.getPort());
251 public void testAddByName() {
252 SetterConfiguration config = new SetterConfiguration(X6.class);
253 config.clear().add("setHost");
255 List<RequiredInterface> required = config.getRequiredInterfaces();
256 Collections.sort(required, new RequiredInterfaceComparator());
257 assertEquals(1, required.size());
258 assertEquals("setHost.0", required.get(0).getName());
260 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
262 required.get(0).setProvider(provided0);
263 scope.publishInterface(provided0, "hello");
266 assertNull(obj.getHost());
267 assertNull(obj.getPort());
269 config.inject(scope, obj);
270 assertEquals("hello", obj.getHost());
271 assertNull(obj.getPort());
277 public void testAddByType() {
278 SetterConfiguration config = new SetterConfiguration(X6.class);
279 config.clear().addSetter(String.class);
281 List<RequiredInterface> required = config.getRequiredInterfaces();
282 Collections.sort(required, new RequiredInterfaceComparator());
283 assertEquals(1, required.size());
284 assertEquals("setHost.0", required.get(0).getName());
286 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
288 required.get(0).setProvider(provided0);
289 scope.publishInterface(provided0, "hello");
292 assertNull(obj.getHost());
293 assertNull(obj.getPort());
295 config.inject(scope, obj);
296 assertEquals("hello", obj.getHost());
297 assertNull(obj.getPort());
303 public void testAddPrivate() {
305 final SetterConfiguration config = new SetterConfiguration(X5.class);
306 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
308 public void run() throws Exception {
311 }, IllegalArgumentException.class);
313 config.setNonPublic(true);
315 config.add("setXyz");
316 assertEquals(1, config.getRequiredInterfaces().size());
322 public void testAddNonExisting() {
323 final SetterConfiguration config = new SetterConfiguration(X6.class);
326 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
328 public void run() throws Exception {
329 config.add("bladibla");
331 }, IllegalArgumentException.class);
332 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
334 public void run() throws Exception {
335 config.addSetter(DataSource.class);
337 }, IllegalArgumentException.class);
343 public void testAddByTypeNonUnique() {
344 final SetterConfiguration config = new SetterConfiguration(X11.class);
346 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
348 public void run() throws Exception {
349 config.addSetter(String.class);
351 }, IllegalArgumentException.class);
357 public void testRemove() {
358 SetterConfiguration config = new SetterConfiguration(X6.class)
360 config.remove("setPort");
362 List<RequiredInterface> required = config.getRequiredInterfaces();
363 Collections.sort(required, new RequiredInterfaceComparator());
364 assertEquals(1, required.size());
365 assertEquals("setHost.0", required.get(0).getName());
367 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
369 required.get(0).setProvider(provided0);
370 scope.publishInterface(provided0, "hello");
373 assertNull(obj.getHost());
374 assertNull(obj.getPort());
376 config.inject(scope, obj);
377 assertEquals("hello", obj.getHost());
378 assertNull(obj.getPort());
384 * @throws NoSuchMethodException DOCUMENT ME!
386 public void testRemoveByMethodObject() throws NoSuchMethodException {
387 SetterConfiguration config = new SetterConfiguration(X6.class)
389 config.remove(X6.class.getMethod("setPort", Integer.class));
391 List<RequiredInterface> required = config.getRequiredInterfaces();
392 Collections.sort(required, new RequiredInterfaceComparator());
393 assertEquals(1, required.size());
394 assertEquals("setHost.0", required.get(0).getName());
396 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
398 required.get(0).setProvider(provided0);
399 scope.publishInterface(provided0, "hello");
402 assertNull(obj.getHost());
403 assertNull(obj.getPort());
405 config.inject(scope, obj);
406 assertEquals("hello", obj.getHost());
407 assertNull(obj.getPort());
413 public void testRemoveNonExisting() {
414 final SetterConfiguration config = new SetterConfiguration(X6.class);
416 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
418 public void run() throws Exception {
419 config.remove("bladibla");
421 }, IllegalArgumentException.class);
427 public void testOverridingSetters() {
428 SetterConfiguration config = new SetterConfiguration(X10.class)
430 assertEquals(2, config.getRequiredInterfaces().size());
432 List<Method> methods = config.getSetters();
433 assertEquals(2, methods.size());
435 for (Method method : methods) {
436 assertEquals(X10.class, method.getDeclaringClass());