Now the component provides read-only access to the interfaces.

[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 83abf3c2302debf477dc907efb5b0ffa7a6358d4..5da0f025b1715a4fa99ecb48228d896ec8e587f9 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
@@ -31,7 +31,9 @@ import org.wamblee.system.core.DefaultRequiredInterface;
 import org.wamblee.system.core.DefaultScope;
 import org.wamblee.system.core.Environment;
 import org.wamblee.system.core.ProvidedInterface;
+import org.wamblee.system.core.ProvidedInterfaces;
 import org.wamblee.system.core.RequiredInterface;
+import org.wamblee.system.core.RequiredInterfaces;
 import org.wamblee.system.core.Scope;
 import org.wamblee.system.core.StringComponent;
 import org.wamblee.system.core.SystemAssemblyException;
@@ -125,10 +127,10 @@ public class ContainerTest extends TestCase {
                 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);
+        RequiredInterfaces required = system.getRequiredInterfaces();
+        assertEquals(0, required.size());
+        ProvidedInterfaces provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
 
         AssertionUtils.assertEquals(new String[] { "start.environment",
                 "start.application" }, _tracker.getEvents(
@@ -180,13 +182,13 @@ public class ContainerTest extends TestCase {
                 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);
+        RequiredInterfaces required = system.getRequiredInterfaces();
+        assertEquals(1, required.size());
+        ProvidedInterfaces provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
     }
 
     public void testCompositeWithExternalDependencesNotProvided() {
@@ -195,7 +197,7 @@ public class ContainerTest extends TestCase {
             Component application = new Application();
             Container system = new Container("all",
                     new Component[] { application }, new ProvidedInterface[0],
-                    application.getRequiredInterfaces());
+                    application.getRequiredInterfaces().toArray());
             system.start();
         } catch (SystemAssemblyException e) {
             return;
@@ -233,18 +235,18 @@ public class ContainerTest extends TestCase {
         Component application = new Application();
         Container system = new Container("all",
                 new Component[] { application }, new ProvidedInterface[0],
-                application.getRequiredInterfaces());
+                application.getRequiredInterfaces().toArray());
         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);
+        RequiredInterfaces required = system.getRequiredInterfaces();
+        assertEquals(2, required.size());
+        ProvidedInterfaces provided = system.getProvidedInterfaces();
+        assertEquals(0, provided.size());
 
     }
 
@@ -350,22 +352,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]);
-        Scope external = new DefaultScope(env.getProvidedInterfaces());
+        container.getRequiredInterfaces().get(0).setProvider(env
+                .getProvidedInterfaces().get(0));
+        container.getRequiredInterfaces().get(1).setProvider(env
+                .getProvidedInterfaces().get(1));
+        Scope external = new DefaultScope(env.getProvidedInterfaces().toArray());
         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 +376,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 +396,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) {
@@ -480,7 +482,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);
@@ -547,7 +549,7 @@ public class ContainerTest extends TestCase {
             }
         }, SystemAssemblyException.class);
 
-        container.connectExternalRequired("1", app.getRequiredInterfaces()[0]
+        container.connectExternalRequired("1", app.getRequiredInterfaces().get(0)
                 .getName(), "y");
 
         ProvidedInterface i = new DefaultProvidedInterface("i", Integer.class);
@@ -560,9 +562,9 @@ public class ContainerTest extends TestCase {
         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);
 
@@ -590,8 +592,8 @@ public class ContainerTest extends TestCase {
 
         // now choose env2
 
-        container.connectExternalProvided(container.getProvidedInterfaces()[0]
-                .getName(), env2.getName(), env2.getProvidedInterfaces()[0]
+        container.connectExternalProvided(container.getProvidedInterfaces().get(0)
+                .getName(), env2.getName(), env2.getProvidedInterfaces().get(0)
                 .getName());
 
         Scope scope = container.start();
@@ -599,7 +601,7 @@ public class ContainerTest extends TestCase {
         // check the value of the provided interface of the container
 
         String value = scope.getInterfaceImplementation(container
-                .getProvidedInterfaces()[0], String.class);
+                .getProvidedInterfaces().get(0), String.class);
         assertNotNull(value);
         assertEquals(value, env2.getString());
         assertFalse(value.equals(env1.getString()));