updated coding rules.

[utils] / system / general / src / test / java / org / wamblee / system / adapters / SetterConfigurationTest.java

diff --git a/system/general/src/test/java/org/wamblee/system/adapters/SetterConfigurationTest.java b/system/general/src/test/java/org/wamblee/system/adapters/SetterConfigurationTest.java
index 2b7bd9187477d85981057caa10d8580edce682e9..ce0a8d89d76dd222d999245d09f2611bf9f05828 100644 (file)
--- a/system/general/src/test/java/org/wamblee/system/adapters/SetterConfigurationTest.java
+++ b/system/general/src/test/java/org/wamblee/system/adapters/SetterConfigurationTest.java
@@ -15,11 +15,14 @@
  */
 package org.wamblee.system.adapters;
 
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
+import javax.sql.DataSource;
+
 import org.wamblee.system.core.DefaultProvidedInterface;
 import org.wamblee.system.core.ProvidedInterface;
 import org.wamblee.system.core.RequiredInterface;
@@ -30,24 +33,26 @@ public class SetterConfigurationTest extends AdapterTestCase {
 
        public void testOneSetter() {
                SetterConfiguration config = new SetterConfiguration(X5.class);
+               config.initAllSetters();
                List<RequiredInterface> required = config.getRequiredInterfaces();
                assertEquals(1, required.size());
-               assertEquals("value", required.get(0).getName());
+               assertEquals("setValue.0", required.get(0).getName());
 
                ProvidedInterface provided = new DefaultProvidedInterface("janse",
                                String.class);
                required.get(0).setProvider(provided);
-               provided.publish("hello", _scope);
+               scope.publishInterface(provided, "hello");
 
                X5 obj = new X5();
                assertNull(obj.getValue());
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getValue());
        }
 
        public void testPrivateSetter() {
                SetterConfiguration config = new SetterConfiguration(X5.class);
                config.setNonPublic(true);
+               config.initAllSetters();
                List<RequiredInterface> required = new ArrayList<RequiredInterface>(
                                config.getRequiredInterfaces());
                Collections.sort(required, new Comparator<RequiredInterface>() {
@@ -57,25 +62,25 @@ public class SetterConfigurationTest extends AdapterTestCase {
                        }
                });
                assertEquals(2, required.size());
-               assertEquals("value", required.get(0).getName());
-               assertEquals("xyz", required.get(1).getName());
+               assertEquals("setValue.0", required.get(0).getName());
+               assertEquals("setXyz.0", required.get(1).getName());
 
                ProvidedInterface providedString = new DefaultProvidedInterface(
                                "janse", String.class);
                assertTrue(required.get(0).implementedBy(providedString));
                required.get(0).setProvider(providedString);
-               providedString.publish("hello", _scope);
+               scope.publishInterface(providedString, "hello");
 
                ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
                                Integer.class);
                assertTrue(required.get(1).implementedBy(providedInt));
                required.get(1).setProvider(providedInt);
-               providedInt.publish(100, _scope);
+               scope.publishInterface(providedInt, 100);
 
                X5 obj = new X5();
                assertNull(obj.getValue());
                assertNull(obj.getXyz());
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getValue());
                assertEquals(100, obj.getXyz().intValue());
        }
@@ -83,6 +88,7 @@ public class SetterConfigurationTest extends AdapterTestCase {
        public void testInheritance() {
                SetterConfiguration config = new SetterConfiguration(X9.class);
                config.setNonPublic(true);
+               config.initAllSetters();
                List<RequiredInterface> required = new ArrayList<RequiredInterface>(
                                config.getRequiredInterfaces());
                Collections.sort(required, new Comparator<RequiredInterface>() {
@@ -92,95 +98,95 @@ public class SetterConfigurationTest extends AdapterTestCase {
                        }
                });
                assertEquals(3, required.size());
-               assertEquals("flag", required.get(0).getName());
-               assertEquals("value", required.get(1).getName());
-               assertEquals("xyz", required.get(2).getName());
+               assertEquals("setFlag.0", required.get(0).getName());
+               assertEquals("setValue.0", required.get(1).getName());
+               assertEquals("setXyz.0", required.get(2).getName());
 
                ProvidedInterface providedBoolean = new DefaultProvidedInterface(
                                "janse", Boolean.class);
                assertTrue(required.get(0).implementedBy(providedBoolean));
                required.get(0).setProvider(providedBoolean);
-               providedBoolean.publish(true, _scope);
+               scope.publishInterface(providedBoolean, true);
 
                ProvidedInterface providedString = new DefaultProvidedInterface(
                                "janse", String.class);
                assertTrue(required.get(1).implementedBy(providedString));
                required.get(1).setProvider(providedString);
-               providedString.publish("hello", _scope);
+               scope.publishInterface(providedString, "hello");
 
                ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
                                Integer.class);
                assertTrue(required.get(2).implementedBy(providedInt));
                required.get(2).setProvider(providedInt);
-               providedInt.publish(100, _scope);
+               scope.publishInterface(providedInt, 100);
 
                X9 obj = new X9();
                assertNull(obj.getValue());
                assertNull(obj.getXyz());
                assertFalse(obj.isFlag());
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getValue());
                assertEquals(100, obj.getXyz().intValue());
                assertTrue(obj.isFlag());
        }
 
        public void testMultipleSetters() {
-               SetterConfiguration config = new SetterConfiguration(X6.class);
+               SetterConfiguration config = new SetterConfiguration(X6.class).initAllSetters();
                List<RequiredInterface> required = config.getRequiredInterfaces();
                Collections.sort(required, new RequiredInterfaceComparator());
                assertEquals(2, required.size());
-               assertEquals("host", required.get(0).getName());
-               assertEquals("port", required.get(1).getName());
+               assertEquals("setHost.0", required.get(0).getName());
+               assertEquals("setPort.0", required.get(1).getName());
 
                ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                                String.class);
                required.get(0).setProvider(provided0);
-               provided0.publish("hello", _scope);
+               scope.publishInterface(provided0, "hello");
 
                ProvidedInterface provided1 = new DefaultProvidedInterface("port",
                                Integer.class);
                required.get(1).setProvider(provided1);
-               provided1.publish(10, _scope);
+               scope.publishInterface(provided1, 10);
 
                X6 obj = new X6();
                assertNull(obj.getHost());
                assertNull(obj.getPort());
 
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getHost());
                assertEquals(10, obj.getPort().intValue());
        }
 
        public void testInvokeWrongType() {
-               final SetterConfiguration config = new SetterConfiguration(X5.class);
+               final SetterConfiguration config = new SetterConfiguration(X5.class).initAllSetters();
                List<RequiredInterface> required = config.getRequiredInterfaces();
                assertEquals(1, required.size());
-               assertEquals("value", required.get(0).getName());
+               assertEquals("setValue.0", required.get(0).getName());
 
                ProvidedInterface provided = new DefaultProvidedInterface("janse",
                                String.class);
                required.get(0).setProvider(provided);
-               provided.publish("hello", _scope);
+               scope.publishInterface(provided, "hello");
 
                final X6 obj = new X6();
                AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
                        @Override
                        public void run() throws Exception {
-                               config.inject(_scope, obj);
+                               config.inject(scope, obj);
                        }
                }, IllegalArgumentException.class);
        }
 
        public void testSetExplicitValue() {
-               SetterConfiguration config = new SetterConfiguration(X5.class);
-               config.values("value").setValue(0, "bladibla");
+               SetterConfiguration config = new SetterConfiguration(X5.class).initAllSetters();
+               config.values("setValue").setValue(0, "bladibla");
 
                List<RequiredInterface> required = config.getRequiredInterfaces();
                assertEquals(0, required.size());
 
                X5 obj = new X5();
                assertNull(obj.getValue());
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("bladibla", obj.getValue());
        }
 
@@ -195,33 +201,71 @@ public class SetterConfigurationTest extends AdapterTestCase {
                assertNull(obj.getHost());
                assertNull(obj.getPort());
 
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
 
                assertNull(obj.getHost());
                assertNull(obj.getPort());
        }
 
-       public void testAdd() {
+       public void testAddByName() {
                SetterConfiguration config = new SetterConfiguration(X6.class);
-               config.clear().add("host");
+               config.clear().add("setHost");
                List<RequiredInterface> required = config.getRequiredInterfaces();
                Collections.sort(required, new RequiredInterfaceComparator());
                assertEquals(1, required.size());
-               assertEquals("host", required.get(0).getName());
+               assertEquals("setHost.0", required.get(0).getName());
 
                ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                                String.class);
                required.get(0).setProvider(provided0);
-               provided0.publish("hello", _scope);
+               scope.publishInterface(provided0, "hello");
 
                X6 obj = new X6();
                assertNull(obj.getHost());
                assertNull(obj.getPort());
 
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getHost());
                assertNull(obj.getPort());
        }
+       
+       public void testAddByType() { 
+               SetterConfiguration config = new SetterConfiguration(X6.class);
+               config.clear().addSetter(String.class);
+               List<RequiredInterface> required = config.getRequiredInterfaces();
+               Collections.sort(required, new RequiredInterfaceComparator());
+               assertEquals(1, required.size());
+               assertEquals("setHost.0", required.get(0).getName());
+
+               ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
+                               String.class);
+               required.get(0).setProvider(provided0);
+               scope.publishInterface(provided0, "hello");
+
+               X6 obj = new X6();
+               assertNull(obj.getHost());
+               assertNull(obj.getPort());
+
+               config.inject(scope, obj);
+               assertEquals("hello", obj.getHost());
+               assertNull(obj.getPort());
+       }
+       
+       public void testAddPrivate() { 
+               X5 obj = new X5();
+               final SetterConfiguration config = new SetterConfiguration(X5.class);
+               AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+                       @Override
+                       public void run() throws Exception {
+                               config.add("xyz");      
+                       }
+               }, IllegalArgumentException.class);
+               
+               config.setNonPublic(true);
+               config.clear();
+               config.add("setXyz");
+               assertEquals(1, config.getRequiredInterfaces().size());
+       }
 
        public void testAddNonExisting() {
                final SetterConfiguration config = new SetterConfiguration(X6.class);
@@ -233,29 +277,68 @@ public class SetterConfigurationTest extends AdapterTestCase {
                                config.add("bladibla");
                        }
                }, IllegalArgumentException.class);
+               AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+                       @Override
+                       public void run() throws Exception {
+                               config.addSetter(DataSource.class);
+                       }
+               }, IllegalArgumentException.class);
+       }
+       
+       public void testAddByTypeNonUnique() { 
+               final SetterConfiguration config = new SetterConfiguration(X11.class);
+               config.clear();
+               AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+                       @Override
+                       public void run() throws Exception {
+                               config.addSetter(String.class);
+                       }
+               }, IllegalArgumentException.class);
        }
 
        public void testRemove() {
-               SetterConfiguration config = new SetterConfiguration(X6.class);
-               config.remove("port");
+               SetterConfiguration config = new SetterConfiguration(X6.class).initAllSetters();
+               config.remove("setPort");
                List<RequiredInterface> required = config.getRequiredInterfaces();
                Collections.sort(required, new RequiredInterfaceComparator());
                assertEquals(1, required.size());
-               assertEquals("host", required.get(0).getName());
+               assertEquals("setHost.0", required.get(0).getName());
 
                ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
                                String.class);
                required.get(0).setProvider(provided0);
-               provided0.publish("hello", _scope);
+               scope.publishInterface(provided0, "hello");
 
                X6 obj = new X6();
                assertNull(obj.getHost());
                assertNull(obj.getPort());
 
-               config.inject(_scope, obj);
+               config.inject(scope, obj);
                assertEquals("hello", obj.getHost());
                assertNull(obj.getPort());
        }
+       
+       public void testRemoveByMethodObject() throws NoSuchMethodException {
+        SetterConfiguration config = new SetterConfiguration(X6.class).initAllSetters();
+        config.remove(X6.class.getMethod("setPort", Integer.class));
+        List<RequiredInterface> required = config.getRequiredInterfaces();
+        Collections.sort(required, new RequiredInterfaceComparator());
+        assertEquals(1, required.size());
+        assertEquals("setHost.0", required.get(0).getName());
+
+        ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
+                String.class);
+        required.get(0).setProvider(provided0);
+        scope.publishInterface(provided0, "hello");
+
+        X6 obj = new X6();
+        assertNull(obj.getHost());
+        assertNull(obj.getPort());
+
+        config.inject(scope, obj);
+        assertEquals("hello", obj.getHost());
+        assertNull(obj.getPort());
+    }
 
        public void testRemoveNonExisting() {
                final SetterConfiguration config = new SetterConfiguration(X6.class);
@@ -267,4 +350,15 @@ public class SetterConfigurationTest extends AdapterTestCase {
                        }
                }, IllegalArgumentException.class);
        }
+       
+       public void testOverridingSetters() { 
+               SetterConfiguration config = new SetterConfiguration(X10.class).initAllSetters();
+               assertEquals(2, config.getRequiredInterfaces().size());
+               List<Method> methods = config.getSetters(); 
+               assertEquals(2, methods.size());
+               for (Method method: methods) { 
+                       assertEquals(X10.class, method.getDeclaringClass());
+               }
+               
+       }
 }