git://wamblee.org / utils / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[utils] / system / general / src / test / java / org / wamblee / system / container / ContainerTest.java
diff --git a/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java b/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java
index 156d4dd6f4222c6748d414287d9a4d71c7d87c1c..41ccede4f6cb5c72efcb1cacaf5a1567b0215dd8 100644 (file)
--- a/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java
+++ b/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java
@@ -77,7 +77,7 @@ public class ContainerTest extends TestCase {
         AssertionUtils.assertEquals(new String[] { "start.environment",
                 "start.application" }, _tracker.getEvents(
                 Thread.currentThread()).toArray(new String[0]));
-        assertEquals(0, scope.getProvidedInterfaces().length);
+        assertEquals(0, scope.getProvidedInterfaces().size());
 
         assertEquals(environment.getString(), application.getString());
         assertEquals(environment.getInteger(), application.getInteger());
@@ -94,7 +94,7 @@ public class ContainerTest extends TestCase {
         AssertionUtils.assertEquals(new String[] { "start.environment",
                 "start.application" }, _tracker.getEvents(
                 Thread.currentThread()).toArray(new String[0]));
-        assertEquals(0, scope.getProvidedInterfaces().length);
+        assertEquals(0, scope.getProvidedInterfaces().size());
 
         assertEquals(environment.getString(), application.getString());
         assertEquals(environment.getInteger(), application.getInteger());
@@ -103,8 +103,8 @@ public class ContainerTest extends TestCase {
 
     public void testApplicationEnvironment() {
         try {
-            Component environment = new Environment();
-            Component application = new Application();
+            Component<?> environment = new Environment();
+            Component<?> application = new Application();
             Container container = new Container("root", new Component[] {
                     application, environment }, new ProvidedInterface[0],
                     new RequiredInterface[0]);
@@ -117,18 +117,18 @@ public class ContainerTest extends TestCase {
     }
 
     public void testComposite() {
-        Component environment = new Environment(_tracker);
-        Component application = new Application(_tracker);
+        Component<?> environment = new Environment(_tracker);
+        Component<?> application = new Application(_tracker);
         assertEquals(0, _tracker.getEventCount());
 
         Container system = new Container("all", new Component[] { environment,
                 application }, new ProvidedInterface[0],
                 new RequiredInterface[0]);
         Scope runtime = system.start();
-        RequiredInterface[] required = system.getRequiredInterfaces();
-        assertEquals(0, required.length);
-        ProvidedInterface[] provided = system.getProvidedInterfaces();
-        assertEquals(0, provided.length);
+        List<RequiredInterface> required = system.getRequiredInterfaces();
+        assertEquals(0, required.size());
+        List<ProvidedInterface> provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
 
         AssertionUtils.assertEquals(new String[] { "start.environment",
                 "start.application" }, _tracker.getEvents(
@@ -144,8 +144,8 @@ public class ContainerTest extends TestCase {
 
     public void testCompositeWithWrongProvidedInfo() {
         try {
-            Component environment = new Environment();
-            Component application = new Application();
+            Component<?> environment = new Environment();
+            Component<?> application = new Application();
             Container system = new Container("all", new Component[] {
                     environment, application },
                     new ProvidedInterface[] { new DefaultProvidedInterface(
@@ -160,8 +160,8 @@ public class ContainerTest extends TestCase {
 
     public void testCompositeRequiredInterfaceNotProvided() {
         try {
-            Component environment = new Environment();
-            Component application = new Application();
+            Component<?> environment = new Environment();
+            Component<?> application = new Application();
             Container system = new Container("all", new Component[] {
                     environment, application }, new ProvidedInterface[0],
                     new RequiredInterface[] { new DefaultRequiredInterface(
@@ -174,40 +174,39 @@ public class ContainerTest extends TestCase {
     }
 
     public void testCompositeWithSuperfluousRequiredInfo() {
-        Component environment = new Environment();
-        Component application = new Application();
+        Component<?> environment = new Environment();
+        Component<?> application = new Application();
         Container system = new Container("all", new Component[] { environment,
                 application }, new ProvidedInterface[0],
                 new RequiredInterface[] { new DefaultRequiredInterface("float",
                         Float.class) });
-        system.getRequiredInterfaces()[0]
+        system.getRequiredInterfaces().get(0)
                 .setProvider(new DefaultProvidedInterface("hallo", Float.class));
         system.start();
-        RequiredInterface[] required = system.getRequiredInterfaces();
-        assertEquals(1, required.length);
-        ProvidedInterface[] provided = system.getProvidedInterfaces();
-        assertEquals(0, provided.length);
+        List<RequiredInterface> required = system.getRequiredInterfaces();
+        assertEquals(1, required.size());
+        List<ProvidedInterface> provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
     }
 
     public void testCompositeWithExternalDependencesNotProvided() {
         try {
-            Component environment = new Environment();
-            Component application = new Application();
+            Component<?> application = new Application();
+           
             Container system = new Container("all",
                     new Component[] { application }, new ProvidedInterface[0],
-                    application.getRequiredInterfaces());
+                    application.getRequiredInterfaces().toArray(new RequiredInterface[0]));
             system.start();
         } catch (SystemAssemblyException e) {
             return;
         }
         fail();
-
     }
 
     public void testDuplicateComponent() {
         try {
-            Component comp1 = new Application();
-            Component comp2 = new Application();
+            Component<?> comp1 = new Application();
+            Component<?> comp2 = new Application();
             Container system = new Container("top");
             system.addComponent(comp1).addComponent(comp2);
         } catch (SystemAssemblyException e) {
@@ -216,9 +215,10 @@ public class ContainerTest extends TestCase {
         fail();
     }
 
+
     public void testInconsistentHierarchy() {
         try {
-            Component comp = new Application();
+            Component<?> comp = new Application();
             Container system = new Container("top").addComponent(comp);
             Container system2 = new Container("top2").addComponent(comp);
         } catch (SystemAssemblyException e) {
@@ -229,30 +229,30 @@ public class ContainerTest extends TestCase {
 
     public void testCompositeWithExternalDependencesProvided() {
 
-        Component environment = new Environment();
-        Component application = new Application();
+        Component<?> environment = new Environment();
+        Component<?> application = new Application();
         Container system = new Container("all",
                 new Component[] { application }, new ProvidedInterface[0],
-                application.getRequiredInterfaces());
+                application.getRequiredInterfaces().toArray(new RequiredInterface[0]));
         environment.start(new DefaultScope(new ProvidedInterface[0]));
-        system.getRequiredInterfaces()[0].setProvider(environment
-                .getProvidedInterfaces()[0]);
-        system.getRequiredInterfaces()[1].setProvider(environment
-                .getProvidedInterfaces()[1]);
+        system.getRequiredInterfaces().get(0).setProvider(environment
+                .getProvidedInterfaces().get(0));
+        system.getRequiredInterfaces().get(1).setProvider(environment
+                .getProvidedInterfaces().get(1));
 
         system.start();
-        RequiredInterface[] required = system.getRequiredInterfaces();
-        assertEquals(2, required.length);
-        ProvidedInterface[] provided = system.getProvidedInterfaces();
-        assertEquals(0, provided.length);
+        List<RequiredInterface> required = system.getRequiredInterfaces();
+        assertEquals(2, required.size());
+        List<ProvidedInterface> provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
 
     }
 
     public void testAmbiguousInterfaces() {
         try {
-            Component environment1 = new Environment();
-            Component environment2 = new Environment();
-            Component application = new Application();
+            Component<?> environment1 = new Environment();
+            Component<?> environment2 = new Environment();
+            Component<?> application = new Application();
             Container container = new Container("root", new Component[] {
                     environment1, environment2, application },
                     new ProvidedInterface[0], new RequiredInterface[0]);
@@ -266,7 +266,7 @@ public class ContainerTest extends TestCase {
 
     public void testIncompleteRequirements() {
         try {
-            Component application = new Application();
+            Component<?> application = new Application();
             Container system = new Container("all",
                     new Component[] { application }, new ProvidedInterface[0],
                     new RequiredInterface[0]);
@@ -350,22 +350,22 @@ public class ContainerTest extends TestCase {
                 new Component[] { application }, new ProvidedInterface[0],
                 Application.required(true));
         Environment env = new Environment();
-        container.getRequiredInterfaces()[0].setProvider(env
-                .getProvidedInterfaces()[0]);
-        container.getRequiredInterfaces()[1].setProvider(env
-                .getProvidedInterfaces()[1]);
+        container.getRequiredInterfaces().get(0).setProvider(env
+                .getProvidedInterfaces().get(0));
+        container.getRequiredInterfaces().get(1).setProvider(env
+                .getProvidedInterfaces().get(1));
         Scope external = new DefaultScope(env.getProvidedInterfaces());
         env.start(external);
 
         container.start(external);
-        assertSame(env.getProvidedInterfaces()[0], container
-                .getRequiredInterfaces()[0].getProvider());
-        assertSame(env.getProvidedInterfaces()[1], container
-                .getRequiredInterfaces()[1].getProvider());
-        assertSame(env.getProvidedInterfaces()[0], application
-                .getRequiredInterfaces()[0].getProvider());
-        assertSame(env.getProvidedInterfaces()[1], application
-                .getRequiredInterfaces()[1].getProvider());
+        assertSame(env.getProvidedInterfaces().get(0), container
+                .getRequiredInterfaces().get(0).getProvider());
+        assertSame(env.getProvidedInterfaces().get(1), container
+                .getRequiredInterfaces().get(1).getProvider());
+        assertSame(env.getProvidedInterfaces().get(0), application
+                .getRequiredInterfaces().get(0).getProvider());
+        assertSame(env.getProvidedInterfaces().get(1), application
+                .getRequiredInterfaces().get(1).getProvider());
     }
 
     public void testOptionalRequiredInterfaceNotProvidedOptionalInternal() {
@@ -374,18 +374,18 @@ public class ContainerTest extends TestCase {
                 new Component[] { application }, new ProvidedInterface[0],
                 Application.required(true));
         Environment env = new Environment();
-        container.getRequiredInterfaces()[0].setProvider(env
-                .getProvidedInterfaces()[0]);
+        container.getRequiredInterfaces().get(0).setProvider(env
+                .getProvidedInterfaces().get(0));
         Scope external = new DefaultScope(new ProvidedInterface[0]);
-        external.publishInterface(env.getProvidedInterfaces()[0], env
+        external.publishInterface(env.getProvidedInterfaces().get(0), env
                 .getString());
         container.start(external);
-        assertSame(env.getProvidedInterfaces()[0], container
-                .getRequiredInterfaces()[0].getProvider());
-        assertNull(container.getRequiredInterfaces()[1].getProvider());
-        assertSame(env.getProvidedInterfaces()[0], application
-                .getRequiredInterfaces()[0].getProvider());
-        assertNull(application.getRequiredInterfaces()[1].getProvider());
+        assertSame(env.getProvidedInterfaces().get(0), container
+                .getRequiredInterfaces().get(0).getProvider());
+        assertNull(container.getRequiredInterfaces().get(1).getProvider());
+        assertSame(env.getProvidedInterfaces().get(0), application
+                .getRequiredInterfaces().get(0).getProvider());
+        assertNull(application.getRequiredInterfaces().get(1).getProvider());
     }
 
     public void testOptionalRequiredInterfaceProvidedMandatoryInternal() {
@@ -394,10 +394,10 @@ public class ContainerTest extends TestCase {
                 new Component[] { application }, new ProvidedInterface[0],
                 Application.required(true));
         Environment env = new Environment();
-        container.getRequiredInterfaces()[0].setProvider(env
-                .getProvidedInterfaces()[0]);
-        container.getRequiredInterfaces()[1].setProvider(env
-                .getProvidedInterfaces()[1]);
+        container.getRequiredInterfaces().get(0).setProvider(env
+                .getProvidedInterfaces().get(0));
+        container.getRequiredInterfaces().get(1).setProvider(env
+                .getProvidedInterfaces().get(1));
         try {
             container.start();
         } catch (SystemAssemblyException e) {
@@ -463,9 +463,71 @@ public class ContainerTest extends TestCase {
         container.connectRequiredProvided("app", null, "env1", null);
         container.start();
         assertEquals(env1.getString(), app.getString());
+        assertEquals(env1.getInteger(), app.getInteger());
+        assertFalse(env2.getString().equals(app.getString()));
+        assertFalse(env2.getInteger().equals(app.getInteger()));
+    }
+    
+    public void testRestrictionWithFromAndToInterfaceName() {
+        Environment env1 = new Environment("env1");
+        Environment env2 = new Environment("env2");
+        Application app = new Application("app");
+        Container container = new Container("top").addComponent(env1)
+                .addComponent(env2).addComponent(app);
+        container.connectRequiredProvided("app", app.getRequiredInterfaces().get(0).getName(), 
+                       "env1", env1.getProvidedInterfaces().get(0).getName());
+        container.connectRequiredProvided("app", app.getRequiredInterfaces().get(1).getName(), 
+                       "env2", env2.getProvidedInterfaces().get(1).getName());
+        container.start();
+        assertEquals(env1.getString(), app.getString());
+        assertEquals(env2.getInteger(), app.getInteger());
         assertFalse(env2.getString().equals(app.getString()));
+        assertFalse(env1.getInteger().equals(app.getInteger()));
+    }
+    
+    public void testRestrictionWrongComponentNames() {
+        Environment env1 = new Environment("env1");
+        Environment env2 = new Environment("env2");
+        Application app = new Application("app");
+        final Container container = new Container("top").addComponent(env1)
+                .addComponent(env2).addComponent(app);
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+               @Override
+               public void run() throws Exception {
+                       container.connectRequiredProvided("app2", null, "env1", null);
+               }
+        }, SystemAssemblyException.class); 
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+               @Override
+               public void run() throws Exception {
+                       container.connectRequiredProvided("app", null, "env3", null);
+               }
+        }, SystemAssemblyException.class); 
+    }
+    
+    public void testRestrictionWrongInterfaceNames() {
+        final Environment env1 = new Environment("env1");
+        Environment env2 = new Environment("env2");
+        final Application app = new Application("app");
+        final Container container = new Container("top").addComponent(env1)
+                .addComponent(env2).addComponent(app);
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+               @Override
+               public void run() throws Exception {
+                       container.connectRequiredProvided("app", 
+                                       app.getRequiredInterfaces().get(0).getName() + "xxx", "env1", null);
+               }
+        }, SystemAssemblyException.class); 
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+               @Override
+               public void run() throws Exception {
+                       container.connectRequiredProvided("app", null, "env1", 
+                                       env1.getProvidedInterfaces().get(0).getName() + "yyy");
+               }
+        }, SystemAssemblyException.class); 
     }
 
+
     public void testProvidedInDifferentScopes() {
         // Scoping problem occurred. Externally and internally provided
         // components clashed
@@ -480,7 +542,7 @@ public class ContainerTest extends TestCase {
 
         ProvidedInterface provided = new DefaultProvidedInterface("hallo",
                 Integer.class);
-        container.getRequiredInterfaces()[0].setProvider(provided);
+        container.getRequiredInterfaces().get(0).setProvider(provided);
 
         Scope external = new DefaultScope(new ProvidedInterface[0]);
         external.publishInterface(provided, 100);
@@ -527,44 +589,81 @@ public class ContainerTest extends TestCase {
                 Thread.currentThread()).toArray(new String[0]));
 
     }
-    
-    public void testNonUniqueRequiredInterface() { 
+
+    public void testNonUniqueRequiredInterface() {
         final Container container = new Container("top");
-        container.addRequiredInterface(new DefaultRequiredInterface("i", Integer.class));
-        container.addRequiredInterface(new DefaultRequiredInterface("x", String.class));
-        container.addRequiredInterface(new DefaultRequiredInterface("y", String.class));
-        
+        container.addRequiredInterface(new DefaultRequiredInterface("i",
+                Integer.class));
+        container.addRequiredInterface(new DefaultRequiredInterface("x",
+                String.class));
+        container.addRequiredInterface(new DefaultRequiredInterface("y",
+                String.class));
+
         Application app = new Application("1");
         container.addComponent(app);
 
-    
-        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { 
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
             @Override
             public void run() throws Exception {
-                container.start();                
+                container.start();
             }
         }, SystemAssemblyException.class);
-           
-        container.connectExternalRequired("1", app.getRequiredInterfaces()[0].getName(), 
-                "y");
-        
+
+        container.connectExternalRequired("1", app.getRequiredInterfaces().get(0)
+                .getName(), "y");
+
         ProvidedInterface i = new DefaultProvidedInterface("i", Integer.class);
         ProvidedInterface x = new DefaultProvidedInterface("x", String.class);
         ProvidedInterface y = new DefaultProvidedInterface("y", String.class);
-    
+
         Scope externalScope = new DefaultScope(new ProvidedInterface[0]);
-        
+
         externalScope.publishInterface(i, 100);
         externalScope.publishInterface(x, "x-value");
         externalScope.publishInterface(y, "y-value");
-        
-        container.getRequiredInterfaces()[0].setProvider(i);
-        container.getRequiredInterfaces()[1].setProvider(x);
-        container.getRequiredInterfaces()[2].setProvider(y);
-        
+
+        container.getRequiredInterfaces().get(0).setProvider(i);
+        container.getRequiredInterfaces().get(1).setProvider(x);
+        container.getRequiredInterfaces().get(2).setProvider(y);
+
         Scope runtime = container.start(externalScope);
-        
+
         assertEquals("y-value", app.getString());
-        
+
+    }
+
+    public void testNonUniqueProvidedInterface() {
+
+        final Container container = new Container("top")
+                .addProvidedInterface(new DefaultProvidedInterface("external",
+                        String.class));
+        Environment env1 = new Environment("env1");
+        Environment env2 = new Environment("env2");
+
+        container.addComponent(env1);
+        container.addComponent(env2);
+
+        AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+            @Override
+            public void run() throws Exception {
+                container.start();
+            }
+        }, SystemAssemblyException.class);
+
+        // now choose env2
+
+        container.connectExternalProvided(container.getProvidedInterfaces().get(0)
+                .getName(), env2.getName(), env2.getProvidedInterfaces().get(0)
+                .getName());
+
+        Scope scope = container.start();
+
+        // check the value of the provided interface of the container
+
+        String value = scope.getInterfaceImplementation(container
+                .getProvidedInterfaces().get(0), String.class);
+        assertNotNull(value);
+        assertEquals(value, env2.getString());
+        assertFalse(value.equals(env1.getString()));
     }
 }
http://utils.wamblee.org