+ system.stop(runtime);
+ AssertionUtils.assertEquals(new String[] { "stop.application",
+ "stop.environment" }, _tracker
+ .getEvents(Thread.currentThread()).toArray(new String[0]));
+
+ }
+
+ public void testCompositeWithWrongProvidedInfo() {
+ try {
+ 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]);
+ system.validate();
+ } catch (SystemAssemblyException e) {
+ return;
+ }
+ fail();
+ }
+
+ public void testCompositeRequiredInterfaceNotProvided() {
+ try {
+ 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) });
+ system.start();
+ } catch (SystemAssemblyException e) {
+ return;
+ }
+ fail();
+ }
+
+ public void testCompositeWithSuperfluousRequiredInfo() {
+ 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));
+ system.start();
+ RequiredInterface[] required = system.getRequiredInterfaces();
+ assertEquals(1, required.length);
+ ProvidedInterface[] provided = system.getProvidedInterfaces();
+ assertEquals(0, provided.length);
+ }
+
+ public void testCompositeWithExternalDependencesNotProvided() {
+ try {
+ Component environment = new Environment();
+ Component application = new Application();
+ Container system = new Container("all",
+ new Component[] { application }, new ProvidedInterface[0],
+ application.getRequiredInterfaces());
+ system.start();
+ } catch (SystemAssemblyException e) {
+ return;
+ }
+ fail();
+
+ }
+
+ public void testDuplicateComponent() {
+ try {
+ 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();
+ Container system = new Container("top").addComponent(comp);
+ Container system2 = new Container("top2").addComponent(comp);
+ } catch (SystemAssemblyException e) {
+ return;
+ }
+ fail();
+ }
+
+ public void testCompositeWithExternalDependencesProvided() {
+
+ Component environment = new Environment();
+ Component application = new Application();
+ Container system = new Container("all",
+ new Component[] { application }, new ProvidedInterface[0],
+ application.getRequiredInterfaces());
+ environment.start(new DefaultScope(new ProvidedInterface[0]));
+ system.getRequiredInterfaces()[0].setProvider(environment
+ .getProvidedInterfaces()[0]);
+ system.getRequiredInterfaces()[1].setProvider(environment
+ .getProvidedInterfaces()[1]);
+
+ system.start();
+ RequiredInterface[] required = system.getRequiredInterfaces();
+ assertEquals(2, required.length);
+ ProvidedInterface[] provided = system.getProvidedInterfaces();
+ assertEquals(0, provided.length);
+
+ }
+
+ public void testAmbiguousInterfaces() {
+ try {
+ 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]);
+ container.start();
+
+ } catch (SystemAssemblyException e) {
+ return;
+ }
+ fail();
+ }
+
+ public void testIncompleteRequirements() {
+ try {
+ Component application = new Application();
+ Container system = new Container("all",
+ 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();
+
+ try {
+ Container container = new Container("root", new Component[] {
+ 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]));
+ return;
+ }
+ fail();
+ }
+
+ public void testEnvironmentApplicationRollbackOnExceptionWithExceptionOnStop()
+ throws Exception {
+ IMocksControl control = EasyMock.createControl();
+
+ 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 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();
+
+ try {
+ Container container = new Container("root", new Component[] {
+ 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]));
+ return;
+ }
+ fail();
+ }
+
+ public void testOptionalRequiredInterfaceProvidedOptionalInternal() {
+ Application application = new Application(true);
+ Container container = new Container("top",
+ 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());
+ 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());
+ }
+
+ public void testOptionalRequiredInterfaceNotProvidedOptionalInternal() {
+ Application application = new Application(true);
+ Container container = new Container("top",
+ new Component[] { application }, new ProvidedInterface[0],
+ Application.required(true));
+ Environment env = new Environment();
+ container.getRequiredInterfaces()[0].setProvider(env
+ .getProvidedInterfaces()[0]);
+ Scope external = new DefaultScope(new ProvidedInterface[0]);
+ external.publishInterface(env.getProvidedInterfaces()[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());
+ }
+
+ public void testOptionalRequiredInterfaceProvidedMandatoryInternal() {
+ Application application = new Application();
+ Container container = new Container("top",
+ 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.start();
+ 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());
+ }
+
+ public void testSealed() {
+ final Container container = new Container("xx");
+ assertFalse(container.isSealed());
+ container.start();
+ assertTrue(container.isSealed());
+
+ AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+ @Override
+ public void run() throws Exception {
+ container.addComponent(new Application());
+ }
+ }, SystemAssemblyException.class);
+
+ AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+ @Override
+ public void run() throws Exception {
+ container.addRestriction(new InterfaceRestriction() {
+ @Override
+ public boolean isViolated(Component aClient,
+ RequiredInterface aRequired, Component aServer,
+ ProvidedInterface aProvided) {
+ return false;
+ }
+ });
+ }
+ }, SystemAssemblyException.class);
+ AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+ @Override
+ public void run() throws Exception {
+ container.addProvidedInterface(new DefaultProvidedInterface(
+ "xx", String.class));
+ }
+ }, SystemAssemblyException.class);
+
+ AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
+ @Override
+ public void run() throws Exception {
+ container.addRequiredInterface(new DefaultRequiredInterface(
+ "xx", String.class));
+ }
+ }, SystemAssemblyException.class);
+ }
+
+ public void testRestriction() {
+ 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.addRestriction(new DefaultInterfaceRestriction("app", null,
+ "env1", null));
+ container.start();
+ assertEquals(env1.getString(), app.getString());
+ assertFalse(env2.getString().equals(app.getString()));
+ }
+
+ 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);
+ container.addRequiredInterface(new DefaultRequiredInterface("integer",
+ Integer.class));
+
+ ProvidedInterface provided = new DefaultProvidedInterface("hallo",
+ Integer.class);
+ container.getRequiredInterfaces()[0].setProvider(provided);
+
+ Scope external = new DefaultScope(new ProvidedInterface[0]);
+ external.publishInterface(provided, 100);
+ Scope scope = container.start(external);
+ }
+
+ public void testProvidedInterfaces() {
+ Environment env = new Environment(_tracker);
+ Container envcontainer = new Container("0").addComponent(env)
+ .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]));
+
+ envcontainer.stop(scope);
+ }
+
+ public void testCoupleTwoContainers() {
+ Environment env = new Environment(_tracker);
+ Container envcontainer = new Container("0").addComponent(env)
+ .addProvidedInterface(
+ new DefaultProvidedInterface("string", String.class))
+ .addProvidedInterface(
+ new DefaultProvidedInterface("integer", Integer.class));
+
+ Application app = new Application(_tracker);
+ Container appcontainer = new Container("1").addComponent(app)
+ .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]));
+
+ }