X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=system%2Fgeneral%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fsystem%2Fcontainer%2FContainerTest.java;h=cbd623e9e963e3ba050552615905da069b455685;hb=49ce7cb8387601982d5e6ef186ce206d38f6e3d7;hp=156d4dd6f4222c6748d414287d9a4d71c7d87c1c;hpb=1a7fade8cf8581099c9cd8edd0bf617979ec1857;p=utils 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 156d4dd6..cbd623e9 100644 --- a/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java +++ b/system/general/src/test/java/org/wamblee/system/container/ContainerTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2007 the original author or authors. + * Copyright 2005-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,9 +21,6 @@ import java.util.List; import junit.framework.TestCase; -import org.easymock.classextension.ConstructorArgs; -import org.easymock.classextension.EasyMock; -import org.easymock.classextension.IMocksControl; import org.wamblee.general.Pair; import org.wamblee.system.core.Component; import org.wamblee.system.core.DefaultProvidedInterface; @@ -36,373 +33,384 @@ import org.wamblee.system.core.Scope; import org.wamblee.system.core.StringComponent; import org.wamblee.system.core.SystemAssemblyException; import org.wamblee.test.AssertionUtils; -import org.wamblee.test.EasyMockMatchers; import org.wamblee.test.EventTracker; +/** + * + * @author $author$ + * @version $Revision$ + */ public class ContainerTest extends TestCase { - - private EventTracker _tracker; + private EventTracker tracker; @Override protected void setUp() throws Exception { super.setUp(); - _tracker = new EventTracker(); - } - - private static class MyMultiple implements Serializable, Runnable { - @Override - public void run() { - // Empty - } + tracker = new EventTracker(); } private List> createProvidedInput( - ProvidedInterface[] aProvided, Component aProvider) { + ProvidedInterface[] aProvided, Component aProvider) { List> result = new ArrayList>(); + for (ProvidedInterface provided : aProvided) { result.add(new Pair(provided, - aProvider)); + aProvider)); } + return result; } public void testEnvironmentApplication() { - Environment environment = new Environment(_tracker); - Application application = new Application(_tracker); + Environment environment = new Environment(tracker); + Application application = new Application(tracker); Container container = new Container("root", new Component[] { - environment, application }, new ProvidedInterface[0], - new RequiredInterface[0]); + environment, application }, new ProvidedInterface[0], + new RequiredInterface[0]); Scope scope = container.start(); assertTrue(container.isSealed()); AssertionUtils.assertEquals(new String[] { "start.environment", - "start.application" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); - assertEquals(0, scope.getProvidedInterfaces().length); + "start.application" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); + assertEquals(0, scope.getProvidedInterfaces().size()); assertEquals(environment.getString(), application.getString()); assertEquals(environment.getInteger(), application.getInteger()); - } public void testEnvironmentApplicationSimpleConstructor() { - Environment environment = new Environment(_tracker); - Application application = new Application(_tracker); + Environment environment = new Environment(tracker); + Application application = new Application(tracker); Container container = new Container("root").addComponent(environment) - .addComponent(application); + .addComponent(application); Scope scope = container.start(); AssertionUtils.assertEquals(new String[] { "start.environment", - "start.application" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); - assertEquals(0, scope.getProvidedInterfaces().length); + "start.application" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); + assertEquals(0, scope.getProvidedInterfaces().size()); assertEquals(environment.getString(), application.getString()); assertEquals(environment.getInteger(), application.getInteger()); - } 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]); + application, environment }, new ProvidedInterface[0], + new RequiredInterface[0]); container.start(); } catch (SystemAssemblyException e) { // e.printStackTrace(); return; } + fail(); } public void testComposite() { - Component environment = new Environment(_tracker); - Component application = new Application(_tracker); - assertEquals(0, _tracker.getEventCount()); + 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]); + 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 required = system.getRequiredInterfaces(); + assertEquals(0, required.size()); + + List provided = system.getProvidedInterfaces(); + assertEquals(0, provided.size()); AssertionUtils.assertEquals(new String[] { "start.environment", - "start.application" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); - _tracker.clear(); + "start.application" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); + tracker.clear(); system.stop(runtime); AssertionUtils.assertEquals(new String[] { "stop.application", - "stop.environment" }, _tracker - .getEvents(Thread.currentThread()).toArray(new String[0])); - + "stop.environment" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); } 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( - "float", Float.class) }, - new DefaultRequiredInterface[0]); + environment, application }, + new ProvidedInterface[] { new DefaultProvidedInterface("float", + Float.class) }, new DefaultRequiredInterface[0]); system.validate(); } catch (SystemAssemblyException e) { return; } + fail(); } 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( - "string", String.class) }); + environment, application }, new ProvidedInterface[0], + new RequiredInterface[] { new DefaultRequiredInterface( + "string", String.class) }); system.start(); } catch (SystemAssemblyException e) { return; } + fail(); } 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] - .setProvider(new DefaultProvidedInterface("hallo", Float.class)); + application }, new ProvidedInterface[0], + new RequiredInterface[] { new DefaultRequiredInterface("float", + Float.class) }); + 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 required = system.getRequiredInterfaces(); + assertEquals(1, required.size()); + + List 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()); + new Component[] { application }, new ProvidedInterface[0], + application.getRequiredInterfaces().toArray( + new RequiredInterface[0])); system.start(); } catch (SystemAssemblyException e) { return; } - fail(); + 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) { return; } + 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); + + ignoredVariable(system); + ignoredVariable(system2); } catch (SystemAssemblyException e) { return; } + fail(); } - public void testCompositeWithExternalDependencesProvided() { + private static void ignoredVariable(Object aObject) { + // for findbugs. + } - Component environment = new Environment(); - Component application = new Application(); + public void testCompositeWithExternalDependencesProvided() { + Component environment = new Environment(); + Component application = new Application(); Container system = new Container("all", - new Component[] { application }, new ProvidedInterface[0], - application.getRequiredInterfaces()); + new Component[] { application }, new ProvidedInterface[0], + 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 required = system.getRequiredInterfaces(); + assertEquals(2, required.size()); + + List 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]); + environment1, environment2, application }, + new ProvidedInterface[0], new RequiredInterface[0]); container.start(); - } catch (SystemAssemblyException e) { return; } + fail(); } 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]); + new Component[] { application }, new ProvidedInterface[0], + new RequiredInterface[0]); system.start(); } catch (SystemAssemblyException e) { return; } + fail(); } public void testEnvironmentApplicationRollbackOnException() - throws Exception { - IMocksControl control = EasyMock.createStrictControl(); - - Environment environment = new Environment(_tracker); - Application application = control.createMock(Application.class, - new ConstructorArgs(Application.class.getConstructor()), - Application.class.getDeclaredMethod("doStart", Scope.class)); - - application.doStart(EasyMockMatchers.anyObject(Scope.class)); - EasyMock.expectLastCall().andThrow(new RuntimeException()); - control.replay(); + throws Exception { + Environment environment = new Environment(tracker); + Application application = new Application() { + @Override + public Object doStart(Scope aScope) { + throw new RuntimeException(); + } + }; try { Container container = new Container("root", new Component[] { - environment, application }, new ProvidedInterface[0], - new RequiredInterface[0]); + environment, application }, new ProvidedInterface[0], + new RequiredInterface[0]); container.start(); } catch (RuntimeException e) { AssertionUtils.assertEquals(new String[] { "start.environment", - "stop.environment" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); + "stop.environment" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); + return; } + fail(); } public void testEnvironmentApplicationRollbackOnExceptionWithExceptionOnStop() - throws Exception { - IMocksControl control = EasyMock.createControl(); + throws Exception { + Environment environment = new Environment(tracker); - Environment environment = new Environment(_tracker); // Application 1 will throw an exception while stopping. - Application application1 = control.createMock(Application.class, - new ConstructorArgs(Application.class.getConstructor()), - Application.class.getDeclaredMethod("doStop", Object.class)); - - application1.doStop(EasyMock.anyObject()); - EasyMock.expectLastCall().andThrow(new RuntimeException()); + Application application1 = new Application("app1") { + @Override + public void doStop(Object aRuntime) { + throw new RuntimeException(); + } + }; // application 2 will throw an exception while starting - Application application2 = control.createMock(Application.class, - new ConstructorArgs(Application.class - .getConstructor(String.class), "application2"), - Application.class.getDeclaredMethod("doStart", Scope.class)); - - application2.doStart(EasyMockMatchers.anyObject(Scope.class)); - EasyMock.expectLastCall().andThrow(new RuntimeException()); - - control.replay(); + Application application2 = new Application("app2") { + public Object doStart(Scope aScope) { + throw new RuntimeException(); + } + }; try { Container container = new Container("root", new Component[] { - environment, application1, application2 }, - new ProvidedInterface[0], new RequiredInterface[0]); + environment, application1, application2 }, + new ProvidedInterface[0], new RequiredInterface[0]); container.start(); } catch (RuntimeException e) { AssertionUtils.assertEquals(new String[] { "start.environment", - "stop.environment" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); + "stop.environment" }, tracker.getEvents(Thread.currentThread()) + .toArray(new String[0])); + return; } + fail(); } public void testOptionalRequiredInterfaceProvidedOptionalInternal() { Application application = new Application(true); Container container = new Container("top", - new Component[] { application }, new ProvidedInterface[0], - Application.required(true)); + 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() { Application application = new Application(true); Container container = new Container("top", - new Component[] { application }, new ProvidedInterface[0], - Application.required(true)); + 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 - .getString()); + 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() { Application application = new Application(); Container container = new Container("top", - new Component[] { application }, new ProvidedInterface[0], - Application.required(true)); + 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) { return; } + fail(); } @@ -441,7 +449,7 @@ public class ContainerTest extends TestCase { @Override public void run() throws Exception { container.addProvidedInterface(new DefaultProvidedInterface( - "xx", String.class)); + "xx", String.class)); } }, SystemAssemblyException.class); @@ -449,7 +457,7 @@ public class ContainerTest extends TestCase { @Override public void run() throws Exception { container.addRequiredInterface(new DefaultRequiredInterface( - "xx", String.class)); + "xx", String.class)); } }, SystemAssemblyException.class); } @@ -459,112 +467,299 @@ public class ContainerTest extends TestCase { Environment env2 = new Environment("env2"); Application app = new Application("app"); Container container = new Container("top").addComponent(env1) - .addComponent(env2).addComponent(app); + .addComponent(env2).addComponent(app); 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 // because unique id generation in the scope was wrong. - StringComponent str = new StringComponent("string"); Application app = new Application("app"); Container container = new Container("top").addComponent(str) - .addComponent(app); + .addComponent(app); container.addRequiredInterface(new DefaultRequiredInterface("integer", - Integer.class)); + Integer.class)); ProvidedInterface provided = new DefaultProvidedInterface("hallo", - Integer.class); - container.getRequiredInterfaces()[0].setProvider(provided); + Integer.class); + container.getRequiredInterfaces().get(0).setProvider(provided); Scope external = new DefaultScope(new ProvidedInterface[0]); external.publishInterface(provided, 100); - Scope scope = container.start(external); + + container.start(external); } public void testProvidedInterfaces() { - Environment env = new Environment(_tracker); + Environment env = new Environment(tracker); Container envcontainer = new Container("0").addComponent(env) - .addProvidedInterface( - new DefaultProvidedInterface("string", String.class)) - .addProvidedInterface( - new DefaultProvidedInterface("integer", Integer.class)); + .addProvidedInterface( + new DefaultProvidedInterface("string", String.class)) + .addProvidedInterface( + new DefaultProvidedInterface("integer", Integer.class)); Scope scope = envcontainer.start(); AssertionUtils.assertEquals(new String[] { "start.environment" }, - _tracker.getEvents(Thread.currentThread()).toArray( - new String[0])); + tracker.getEvents(Thread.currentThread()).toArray(new String[0])); envcontainer.stop(scope); } public void testCoupleTwoContainers() { - Environment env = new Environment(_tracker); + Environment env = new Environment(tracker); Container envcontainer = new Container("0").addComponent(env) - .addProvidedInterface( - new DefaultProvidedInterface("string", String.class)) - .addProvidedInterface( - new DefaultProvidedInterface("integer", Integer.class)); + .addProvidedInterface( + new DefaultProvidedInterface("string", String.class)) + .addProvidedInterface( + new DefaultProvidedInterface("integer", Integer.class)); - Application app = new Application(_tracker); + Application app = new Application(tracker); Container appcontainer = new Container("1").addComponent(app) - .addRequiredInterface( - new DefaultRequiredInterface("string", String.class)) - .addRequiredInterface( - new DefaultRequiredInterface("integer", Integer.class)); + .addRequiredInterface( + new DefaultRequiredInterface("string", String.class)) + .addRequiredInterface( + new DefaultRequiredInterface("integer", Integer.class)); Container top = new Container("top"); top.addComponent(envcontainer).addComponent(appcontainer); top.start(); AssertionUtils.assertEquals(new String[] { "start.environment", - "start.application" }, _tracker.getEvents( - Thread.currentThread()).toArray(new String[0])); - + "start.application" }, tracker.getEvents(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); - - Scope runtime = container.start(externalScope); - + + container.getRequiredInterfaces().get(0).setProvider(i); + container.getRequiredInterfaces().get(1).setProvider(x); + container.getRequiredInterfaces().get(2).setProvider(y); + + container.start(externalScope); + assertEquals("y-value", app.getString()); - + } + + public void testNonUniqueRequiredInterfaceWrongNames() { + 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)); + + final Application app = new Application("1"); + container.addComponent(app); + + // wrong component name. + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container.connectExternalRequired("2", "x", "y"); + } + }, SystemAssemblyException.class); + + // Wrong interface name of component. + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container.connectExternalRequired("1", app + .getRequiredInterfaces().get(0).getName() + + "xxx", "y"); + } + }, SystemAssemblyException.class); + + // Wrong external interface name of container + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container.connectExternalRequired("1", app + .getRequiredInterfaces().get(0).getName(), "z"); + } + }, SystemAssemblyException.class); + } + + 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())); + } + + public void testNonUniqueProvidedInterfaceWrongNames() { + final Container container = new Container("top") + .addProvidedInterface(new DefaultProvidedInterface("external", + String.class)); + final Environment env1 = new Environment("env1"); + final Environment env2 = new Environment("env2"); + + container.addComponent(env1); + container.addComponent(env2); + + // Wrong external provided interface name + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container + .connectExternalProvided(container.getProvidedInterfaces() + .get(0).getName() + + "xx", "env1", env1.getProvidedInterfaces().get(0) + .getName()); + } + }, SystemAssemblyException.class); + + // Wrong provided interface name. + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container.connectExternalProvided(container + .getProvidedInterfaces().get(0).getName(), "env1", env1 + .getProvidedInterfaces().get(0).getName() + + "xx"); + } + }, SystemAssemblyException.class); + + // Wrong provided component + AssertionUtils.assertException(new AssertionUtils.ErroneousCode() { + @Override + public void run() throws Exception { + container.connectExternalProvided(container + .getProvidedInterfaces().get(0).getName(), "env3", env1 + .getProvidedInterfaces().get(0).getName()); + } + }, SystemAssemblyException.class); + } + + private static class MyMultiple implements Serializable, Runnable { + @Override + public void run() { + // Empty + } } }