CompositeTest.java

/**
 * Copyright 2011-2012 Universite Joseph Fourier, LIG, ADELE team
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
package fr.imag.adele.apam.test.testcases;

import static org.ops4j.pax.exam.CoreOptions.systemPackage;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
import org.ops4j.pax.exam.spi.reactors.PerMethod;

import fr.imag.adele.apam.CST;
import fr.imag.adele.apam.Component;
import fr.imag.adele.apam.Composite;
import fr.imag.adele.apam.CompositeType;
import fr.imag.adele.apam.Implementation;
import fr.imag.adele.apam.Instance;
import fr.imag.adele.apam.Link;
import fr.imag.adele.apam.ManagerModel;
import fr.imag.adele.apam.impl.ImplementationImpl;
import fr.imag.adele.apam.pax.test.av.spec.MediaControlPoint;
import fr.imag.adele.apam.pax.test.impl.deviceSwitch.GenericSwitch;
import fr.imag.adele.apam.pax.test.implS2.S2InnerImpl;
import fr.imag.adele.apam.pax.test.implS2.S2MiddleImpl;
import fr.imag.adele.apam.pax.test.implS2.S2OutterImpl;
import fr.imag.adele.apam.pax.test.implS3.S3GroupAImpl;
import fr.imag.adele.apam.pax.test.implS3.S3GroupBImpl;
import fr.imag.adele.apam.tests.helpers.Constants;
import fr.imag.adele.apam.tests.helpers.ExtensionAbstract;

@RunWith(PaxExam.class)
@ExamReactorStrategy(PerMethod.class)
public class CompositeTest extends ExtensionAbstract {

	@Test
	public void CascadeDependencyInstantiation_tc031() {

		Implementation ct1 = waitForImplByName(null,
				"fr.imag.adele.apam.pax.test.implS2.S2InnerImpl");

		Assert.assertTrue(ct1 != null);

		auxListInstances("before instantiation-");

		Instance instance = ct1.createInstance(null,
				new HashMap<String, String>());

		String messageDefault = "Considering A->B meaning A depends on B. In the relation A-B->C, A is considered the inner most, and C the outter most. %s";

		try {

			// Means that the inner was injected
			Assert.assertTrue(String.format(messageDefault,
					"The inner most instance was not created"), instance
					.getServiceObject() != null);

			S2InnerImpl innerObject = (S2InnerImpl) instance.getServiceObject();

			Assert.assertTrue(String.format(messageDefault,
					"The middle instance was not created"), innerObject
					.getMiddle() != null);

			S2MiddleImpl middleObject = (S2MiddleImpl) innerObject.getMiddle();

			Assert.assertTrue(String.format(messageDefault,
					"The outter most instance was not created"), middleObject
					.getOutter() != null);

			S2OutterImpl outterObject = (S2OutterImpl) middleObject.getOutter();

			auxListInstances("after instantiation-");

		} catch (ClassCastException castException) {
			Assert.fail("Enclosed implementation do not correspond to the right implementation. AImpl->BImpl->CImpl but the wrong implementation was injected");
		}

	}

	@Test
	public void ComponentMngtLocalWithImplementation_tc033() {

		final String messageTemplate = "Two composites A and B, each of them have their own mainimpl as IA and IB. "
				+ "Both IA and IB have an attribute that depends on the specification X. "
				+ "If an X instance is created into A and this instance is marked as local, this instance cannot be used by other composite. %s";

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-local-implementation",200000);

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Composite composite_a = (Composite) cta.createInstance(null, null);
		Composite composite_b = (Composite) ctb.createInstance(null, null);

		Instance a = composite_a.getMainInst();

		Instance b = composite_b.getMainInst();

		S3GroupAImpl ga = (S3GroupAImpl) a.getServiceObject();

		S3GroupBImpl gb = (S3GroupBImpl) b.getServiceObject();

		// Force instantiation one given specification inside the composite A
		ga.getElement();

		// Force instantiation of the same specification as before in composite
		// B
		gb.getElement();

		auxListInstances("---");

		String message = String
				.format(messageTemplate,
						"But A marked with <export implementation=false />"
								+ " allowed its instance to be used by another composite");
		// Normal !
		Assert.assertTrue(message, ga.getElement() == gb.getElement());

	}

	@Test
	public void ComponentMngtLocalWithInstance_tc032() {

		final String messageTemplate = "Two composites A and B, each of them have their own mainimpl as IA and IB. "
				+ "Both IA and IB have an attribute that depends on the specification X. "
				+ "If an X instance is created into A and this instance is marked as local, this instance cannot be used by other composite. %s";

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-local-instance");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Composite composite_a = (Composite) cta.createInstance(null, null);
		Composite composite_b = (Composite) ctb.createInstance(null, null);

		Instance a = composite_a.getMainInst();
		Instance b = composite_b.getMainInst();

		S3GroupAImpl ga = (S3GroupAImpl) a.getServiceObject();

		S3GroupBImpl gb = (S3GroupBImpl) b.getServiceObject();

		// Force instantiation one given specification inside the composite A
		System.out.println("A-->" + ga.getElement());

		// Force instantiation of the same specification as before in composite
		// B
		System.out.println("B-->" + gb.getElement());

		auxListInstances("---");

		String message = String
				.format(messageTemplate,
						"But A marked with '<local instance='true'>' allowed its instance to be used by another composite");

		Assert.assertTrue(message, ga.getElement() != gb.getElement());

	}

	@Test
	public void ComponentMngtMainCompositeAccessItsPrivateImpls_tc118() {

		final String messageTemplate = "Composite A declares <export implementation='false' /> and its main implem depends on this implementation. %s";

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-local-implementation");

		Composite composite_a = (Composite) cta.createInstance(null, null);

		Implementation dependencyOfA = waitForImplByName(null, "BoschSwitch");
		CompositeType rootComposite = (CompositeType) waitForImplByName(null,
				CST.ROOT_COMPOSITE_TYPE);

		/**
		 * Make sure that the dependency is in the same composite as group-a
		 */
		((ImplementationImpl) dependencyOfA).removeInComposites(rootComposite);
		((ImplementationImpl) dependencyOfA).addInComposites(cta);

		Implementation groupAImpl = waitForImplByName(null, "group-a");

		Instance groupAInstance = groupAImpl.createInstance(composite_a,
				Collections.<String, String> emptyMap());

		S3GroupAImpl ga = (S3GroupAImpl) groupAInstance.getServiceObject();

		// Force instantiation one given specification inside the composite A
		System.out.println("A-->" + ga.getElement());

		auxListInstances("---");

		String message = String
				.format(messageTemplate,
						"A should have visibility to the implementation, just NOT export them, so the composite A should be able to create an instance of it");

		Assert.assertTrue(message, ga.getElement() != null);

	}

	@Test
	public void ComponentMngtNoMainLocalInstance_tc120() {

		final String messageTemplate = "Two composites A and B,  both without mainimpl, B depends on instances inside A, but A is marked as '<export instance='false' />'. %s";

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-local-instance-nomain");

		Composite composite_a = (Composite) cta.createInstance(null, null);

		Implementation groupAImpl = waitForImplByName(null, "group-a");
		Implementation groupBImpl = waitForImplByName(null, "group-b");

		Instance groupAInstance = groupAImpl.createInstance(composite_a,
				Collections.<String, String> emptyMap());
		Instance groupBInstance = groupBImpl.createInstance(null,
				Collections.<String, String> emptyMap());

		S3GroupAImpl ga = (S3GroupAImpl) groupAInstance.getServiceObject();

		S3GroupBImpl gb = (S3GroupBImpl) groupBInstance.getServiceObject();

		// Force instantiation one given specification inside the composite A
		System.out.println("A-->" + ga.getElement());

		// Force instantiation of the same specification as before in composite
		// B
		System.out.println("B-->" + gb.getElement());

		auxListInstances("---");

		String message = String
				.format(messageTemplate,
						"B should have created a new instance, since he has access to the implementation but not the instances of A");

		Assert.assertTrue(message, ga.getElement() != gb.getElement());

	}

	@Test
	public void CompositeContentMngtExportApplicationEverythingGlobalNothingInstance_tc038() {

		CompositeType appCompositeType = (CompositeType) waitForImplByName(
				null, "composite-a");

		Composite appComposite = (Composite) appCompositeType.createInstance(
				null, null);

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-export-application-everything-global-nothing");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Implementation ia = waitForImplByName(null, "group-a");

		Composite composite_a = (Composite) cta.createInstance(appComposite,
				null);
		Composite composite_b = (Composite) ctb.createInstance(appComposite,
				null);

		Instance instanceApp1 = ia.createInstance(composite_a, null);

		Instance instanceApp2 = ia.createInstance(composite_b, null);

		S3GroupAImpl ga1 = (S3GroupAImpl) instanceApp1.getServiceObject();

		S3GroupAImpl ga2 = (S3GroupAImpl) instanceApp2.getServiceObject();

		System.out.println("instanceApp1 is in appli "
				+ instanceApp1.getAppliComposite());
		System.out.println("instanceApp2 is in appli "
				+ instanceApp2.getAppliComposite());

		ga1.getElement();

		apam.waitForIt(Constants.CONST_WAIT_TIME);

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		ga2.getElement();

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String message = "A composite that share its dependencies into application level, should be allowED to inject its instances into other composites that are into the same application.";
		// They are not in the same application !
		Assert.assertTrue(message, ga1.getElement() == ga2.getElement());

	}

	@Test
	public void CompositeContentMngtExportApplicationNothingGlobalEverythingInstance_tc048() {

		CompositeType appCompositeType = (CompositeType) waitForImplByName(
				null, "composite-a");

		Composite superparent = (Composite) appCompositeType.createInstance(
				null, null);

		Composite appCompositeA = (Composite) appCompositeType.createInstance(
				superparent, null);

		CompositeType appCompositeTypeC = (CompositeType) waitForImplByName(
				null, "composite-c");

		Composite appCompositeC = (Composite) appCompositeTypeC.createInstance(
				superparent, null);

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-export-application-nothing-global-everything");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Implementation ia = waitForImplByName(null, "group-a");

		Composite composite_a = (Composite) cta.createInstance(appCompositeA,
				null);
		Composite composite_b = (Composite) ctb.createInstance(appCompositeC,
				null);

		Instance instanceApp1 = ia.createInstance(composite_a, null);

		Instance instanceApp2 = ia.createInstance(composite_b, null);

		S3GroupAImpl ga1 = (S3GroupAImpl) instanceApp1.getServiceObject();

		S3GroupAImpl ga2 = (S3GroupAImpl) instanceApp2.getServiceObject();

		ga1.getElement();

		apam.waitForIt(Constants.CONST_WAIT_TIME);

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		ga2.getElement();

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String message = "Consider composite A, instantiated into a composite SA, and B, into a composite SB. If A declares that export nothing to all app but everything to global, the global take over, and the instances of A should be visible in B";
		// Test faux ?? : ce sont deux appli differentes
		Assert.assertTrue(message, ga1.getElement() == ga2.getElement());

	}

	@Test
	public void CompositeContentMngtExportApplicationNothingGlobalEverythingInstance_tc049() {

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-export-application-nothing-global-everything");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Implementation ia = waitForImplByName(null, "group-a");

		Composite composite_a = (Composite) cta.createInstance(null, null);
		Composite composite_b = (Composite) ctb.createInstance(null, null);

		Instance instanceApp1 = ia.createInstance(composite_a, null);

		Instance instanceApp2 = ia.createInstance(composite_b, null);

		S3GroupAImpl ga1 = (S3GroupAImpl) instanceApp1.getServiceObject();

		S3GroupAImpl ga2 = (S3GroupAImpl) instanceApp2.getServiceObject();

		ga1.getElement();

		apam.waitForIt(Constants.CONST_WAIT_TIME);

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		ga2.getElement();

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String message = "Consider composite A, instantiated into the ROOT composite, and B, into the ROOT composite. If A declares that export nothing to all app but everything to global, the global take over, and the instances of A should be visible in B";

		Assert.assertTrue(message, ga1.getElement() == ga2.getElement());

	}

	@Test
	public void CompositeContentMngtExportGlobalEverythingInstance_tc050() {

		CompositeType cta = (CompositeType) waitForImplByName(null,"composite-a-export-global-everything");

		CompositeType ctb = (CompositeType) waitForImplByName(null,"composite-b");

		Implementation ia = waitForImplByName(null, "group-a");

		Composite composite_a = (Composite) cta.createInstance(null,null);
		Composite composite_b = (Composite) ctb.createInstance(null,null);

		Instance instanceApp1 = ia.createInstance(composite_a, null);

		Instance instanceApp2 = ia.createInstance(composite_b, null);

		S3GroupAImpl ga1 = (S3GroupAImpl) instanceApp1.getServiceObject();

		S3GroupAImpl ga2 = (S3GroupAImpl) instanceApp2.getServiceObject();

		ga1.getElement();

		apam.waitForIt(Constants.CONST_WAIT_TIME);

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		ga2.getElement();

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String message = "Consider composite A, instantiated into a composite SA, and B, into a composite SB. If A declares that export everything globally, its instances should be visible/injected in B";

		Assert.assertTrue(message, ga1.getElement() == ga2.getElement());

	}

	@Test
	public void CompositeContentMngtExportGlobalDynamicInstance() {

		Implementation ia = waitForImplByName(null, "group-a");
		
		/*
		 * create application A
		 */
		CompositeType cta 		= (CompositeType) waitForImplByName(null,"composite-a-export-dynamic");
		Composite composite_a	= (Composite) cta.createInstance(null,Collections.singletonMap("instance.name", "A"));
		Instance source_in_a 	= ia.createInstance(composite_a, Collections.singletonMap("instance.name", "source_in_a"));
		S3GroupAImpl ga_in_a 	= (S3GroupAImpl) source_in_a.getServiceObject();
		
		/*
		 * Force resolution of an instance internally in A
		 */
		ga_in_a.getElement();
		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		/*
		 * export the target of the resolution
		 */
		composite_a.setProperty("composite-dynamic-property", source_in_a.getLinkDest("element").getName());
		
		/*
		 * create application B
		 */
		CompositeType ctb 		= (CompositeType) waitForImplByName(null,"composite-b");
		Composite composite_b 	= (Composite) ctb.createInstance(null,Collections.singletonMap("instance.name", "B"));

		
		/*
		 * create an instance in B and try to get it resolved against the exported content of A, it should be exported
		 */
		Instance source_in_b 	= ia.createInstance(composite_b, Collections.singletonMap("instance.name", "source_in_b"));
		S3GroupAImpl ga_in_b 	= (S3GroupAImpl) source_in_b.getServiceObject();
		ga_in_b.getElement();
		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		String message = "Consider composites A and B. If A declares that dynamically export everything globally, its instances should be visible/injected in B";
		Assert.assertTrue(message, ga_in_a.getElement() == ga_in_b.getElement());
		
		/*
		 * change dynamically the export condition
		 */
		composite_a.setProperty("composite-dynamic-property", "none");
		
		/*
		 * break previous resolution
		 */
		source_in_b.getLink("element").remove();
		
		/*
		 * try to resolve again, must not see the contents of A
		 */
		ga_in_b.getElement();
		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		message = "Consider composites A and B. If A declares that dynamically export nothing globally, its instances should not be visible/injected in B";
		Assert.assertTrue(message, ga_in_a.getElement() != ga_in_b.getElement());

	}
	
	@Test
	public void CompositeContentMngtImportNothingImplementation_tc035() {

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-import-nothing-implementation");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Composite composite_a = (Composite) cta.createInstance(null, null);
		Composite composite_b = (Composite) ctb.createInstance(null, null);

		Instance a = composite_a.getMainInst();

		Instance b = composite_b.getMainInst();

		S3GroupAImpl ga = (S3GroupAImpl) a.getServiceObject();

		S3GroupBImpl gb = (S3GroupBImpl) b.getServiceObject();

		System.out.println("Element B injected: " + gb.getElement());

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		System.out.println("Element A injected: " + ga.getElement());

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String messageTemplate = "Composite that do not allow anything to be imported (<import implementation='false' />) should never import other composite instance. %s";

		String message = String
				.format(messageTemplate,
						"Although, an instance from composite B was injected in composite A even if A is marked with <import implementation='false' />");
		// The fact the implem is not visible does not mean we cannot resolve :
		// it can be deployed again,
		// and it is possible to see its instances anyway !.
		Assert.assertTrue(message, ga.getElement() == gb.getElement());

	}

	@Test
	public void CompositeContentMngtImportNothingInstance_tc034() {

		CompositeType cta = (CompositeType) waitForImplByName(null,
				"composite-a-import-nothing-instance");

		CompositeType ctb = (CompositeType) waitForImplByName(null,
				"composite-b");

		Composite composite_a = (Composite) cta.createInstance(null, null);
		Composite composite_b = (Composite) ctb.createInstance(null, null);

		Instance a = composite_a.getMainInst();

		Instance b = composite_b.getMainInst();

		S3GroupAImpl ga = (S3GroupAImpl) a.getServiceObject();

		S3GroupBImpl gb = (S3GroupBImpl) b.getServiceObject();

		gb.getElement();

		auxListInstances("bbbbbbbbbbbbbbbbbbbbbbbb");

		ga.getElement();

		auxListInstances("aaaaaaaaaaaaaaaaaaaaaaaa");

		String messageTemplate = "Composite that do not allow anything to be imported (<import instance='false' />) should never use other composite instance. %s";

		String message = String
				.format(messageTemplate,
						"Although, an instance from composite B was injected in composite A even if A is marked with import instance='false'");

		Assert.assertTrue(message, ga.getElement() != gb.getElement());

	}

	@Test
	public void CompositePromoteImplicitAndInternal_tct007() {
		CompositeType ctAV00 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-00");
		Composite instAV00 = (Composite) ctAV00.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);

		apam.waitForIt(1000);

		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV00,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-00 should contains an instance named AVEntertainment-Controller (started by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();
		Assert.assertEquals(
				"Two media RENDERERS should be resolved (internal to composite)",
				mediaCtl.resolveRenderersNumber(), 2);
		mediaCtl.resolveServersNumber();
		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
		}

		for (Link link : instAV00.getLinks("promotedServers")) {
			System.out.println("Promoted Server --> "
					+ link.getDestination().getName());
		}

		Assert.assertEquals(
				"Two media SERVERS should be resolved (one internal (with constraints) and one external using promoted relation (with same constraints)",
				mediaCtl.resolveServersNumber(), 2);
	}

	@Test
	public void CompositePromoteImplicitAndInternalbis_tct008() {
		CompositeType ctAV01 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-01");
		Composite instAV00 = (Composite) ctAV01.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);

		apam.waitForIt(2000);

		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV01,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-01 should contains an instance named AVEntertainment-Controller (started by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();
		mediaCtl.resolveServersNumber();

		Assert.assertEquals(
				"Two media renderers should be resolved (internal to composite)",
				mediaCtl.resolveRenderersNumber(), 2);
		mediaCtl.resolveServersNumber();
		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
		}

		Assert.assertEquals(
				"Two media server should be resolved (one internal (without constraints) and one external using promoted relation (with same constraints)",
				mediaCtl.resolveServersNumber(), 2);
	}

	@Test
	public void CompositePromoteMultipleExplicitImplem_tct009() {
		CompositeType ctAV02 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-02");
		Composite instAV02 = (Composite) ctAV02.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);

		Implementation tablet = waitForImplByName(null, "SmartTabletDevice");
		Assert.assertNotNull(
				"SmartTabletDevice implementation should not be null", tablet);
		tablet.createInstance(null, null);

		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV02,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-02 should contains an instance named AVEntertainment-Controller (start by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();

		mediaCtl.resolveServersNumber();

		for (Link link : instAV02.getLinks("promotedServers")) {
			System.out.println("Promoted Server --> "
					+ link.getDestination().getName());
		}

		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
			if (!link.isPromotion()) {
				Assert.fail("Found a link for whose destination is NOT a promotion");
			}
		}

		Assert.assertEquals(
				"Two media renderers should be resolved (internal to composite)",
				2, mediaCtl.resolveRenderersNumber());
		Assert.assertEquals(
				"Only one media server should be resolved (external, using promoted relation only",
				1, mediaCtl.resolveServersNumber());

		Assert.assertTrue(
				"One remote controller should be resolved (external, in root composite)",
				mediaCtl.resolveRemoteControl());
		//
		// for (Instance inst : instAV01.getContainInsts())
		// System.out.println("--> " + inst.getName());

	}

	@Test
	public void CompositePromoteMultipleExplicitSpec_tct010() {
		CompositeType ctAV03 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-03");
		Composite instAV02 = (Composite) ctAV03.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);
		Implementation tablet = waitForImplByName(null, "SmartTabletDevice");
		Assert.assertNotNull(
				"SmartTabletDevice implementation should not be null", tablet);
		tablet.createInstance(null, null);

		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV03,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-03 should contains an instance named AVEntertainment-Controller (start by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();
		mediaCtl.resolveServersNumber();

		for (Link link : instAV02.getLinks("promotedServers")) {
			System.out.println("Promoted Server --> "
					+ link.getDestination().getName());
		}

		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
			if (!link.isPromotion()) {
				Assert.fail("Found a link for whose destination is NOT a promotion");
			}
		}

		Assert.assertEquals(
				"Two media renderers should be resolved (internal to composite)",
				mediaCtl.resolveRenderersNumber(), 2);
		Assert.assertEquals(
				"Only one media server should be resolved (external, using promoted relation only",
				mediaCtl.resolveServersNumber(), 1);
		Assert.assertTrue(
				"One remote controller should be resolved (external, in root composite)",
				mediaCtl.resolveRemoteControl());
		//
		// for (Instance inst : instAV01.getContainInsts())
		// System.out.println("--> " + inst.getName());

	}

	@Test
	public void CompositePromoteSingleExplicitImplem_tct011() {
		CompositeType ctAV02 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-02");
		Composite instAV02 = (Composite) ctAV02.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);

		Implementation tablet = waitForImplByName(null, "SmartTabletDevice");
		Assert.assertNotNull(
				"SmartTabletDevice implementation should not be null", tablet);
		tablet.createInstance(null, null);
		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV02,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-02 should contains an instance named AVEntertainment-Controller (start by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();
		mediaCtl.resolveRemoteControl();

		for (Link link : instAV02.getLinks("promotedRemoteControl")) {
			System.out.println("Promoted remote control --> "
					+ link.getDestination().getName());
		}

		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
			if (!link.isPromotion()) {
				Assert.fail("Found a link for whose destination is NOT a promotion");
			}
		}

		Assert.assertTrue(
				"One remote controller should be resolved (external, in root composite)",
				mediaCtl.resolveRemoteControl());
		//
		// for (Instance inst : instAV01.getContainInsts())
		// System.out.println("--> " + inst.getName());

	}

	@Test
	public void CompositePromoteSingleExplicitSpec_tct012() {
		CompositeType ctAV03 = (CompositeType) waitForImplByName(null,
				"AVEntertainment-03");
		Composite instAV02 = (Composite) ctAV03.createInstance(null, null);
		CompositeType ctDC00 = (CompositeType) waitForImplByName(null,
				"HomeDigitalContent-00");
		Composite instDC00 = (Composite) ctDC00.createInstance(null, null);

		Implementation tablet = waitForImplByName(null, "SmartTabletDevice");
		Assert.assertNotNull(
				"SmartTabletDevice implementation should not be null", tablet);
		tablet.createInstance(null, null);

		auxListInstances();
		Instance instCtl = waitForInstByName(ctAV03,
				"AVEntertainment-Controller");
		Assert.assertNotNull(
				"Composite AVEntertainment-03 should contains an instance named AVEntertainment-Controller (start by the composite)",
				instCtl);

		MediaControlPoint mediaCtl = (MediaControlPoint) instCtl
				.getServiceObject();
		mediaCtl.resolveRemoteControl();

		auxListInstances();

		for (Link link : instAV02.getLinks("promotedRemoteControl")) {
			System.out.println("Promoted remote control --> "
					+ link.getDestination().getName());
		}

		for (Link link : instCtl.getLinks("theServers")) {
			System.out.println("AVEntertainment-Controller links --> "
					+ link.getDestination().getName());
			if (!link.isPromotion()) {
				Assert.fail("Found a link for whose destination is NOT a promotion");
			}
		}

		Assert.assertTrue(
				"One remote controller should be resolved (external, in root composite)",
				mediaCtl.resolveRemoteControl());
		//
		// for (Instance inst : instAV01.getContainInsts())
		// System.out.println("--> " + inst.getName());

	}

	@Test
	public void CompositeTypeInstantiation_tc028() {
		// apam.waitForIt(200000);

		CompositeType ct = (CompositeType) waitForImplByName(null,
				"S2Impl-composite-1");

		Assert.assertTrue("Failed to create the instance of CompositeType",
				ct != null);

		Instance instApp = ct.createInstance(null,
				new HashMap<String, String>());

		Assert.assertTrue("Failed to create the instance of CompositeType",
				instApp != null);
	}

	@Test
	public void CompositeTypeRetrieveServiceObject_tc030() {
		waitForApam();
		waitForImplByName(null, "philipsSwitch");

		CompositeType composite = CST.apam.createCompositeType(null,
				"eletronic-device-compotype", null, "philipsSwitch",
				new HashSet<ManagerModel>(), new HashMap<String, String>());

		Assert.assertTrue(
				"Should be possible to create a composite through API using createCompositeType method",
				composite != null);

		Instance instance = composite.createInstance(null, null);

		Assert.assertTrue("Failed to create instance of the compotype",
				instance != null);

		GenericSwitch serviceObject = (GenericSwitch) instance
				.getServiceObject();

		Assert.assertTrue("Failed to retrieve service as object ",
				serviceObject != null);

	}

	@Override
	public List<Option> config() {
		Map<String, String> mapOfRequiredArtifacts = new HashMap<String, String>();
		mapOfRequiredArtifacts.put("apam-pax-samples-impl-s1",
				"fr.imag.adele.apam.tests.services");
		mapOfRequiredArtifacts.put("apam-pax-samples-impl-s2",
				"fr.imag.adele.apam.tests.services");
		mapOfRequiredArtifacts.put("apam-pax-samples-impl-s3",
				"fr.imag.adele.apam.tests.services");
		mapOfRequiredArtifacts.put("apam-pax-samples-iface",
				"fr.imag.adele.apam.tests.services");
		mapOfRequiredArtifacts.put("apam-pax-composite-av",
				"fr.imag.adele.apam.tests.app");
		mapOfRequiredArtifacts.put("apam-pax-samples-impl-s8",
				"fr.imag.adele.apam.tests.services");
		mapOfRequiredArtifacts.put("apam-pax-samples-impl-s8-dep",
				"fr.imag.adele.apam.tests.services");

		List<Option> addon = super.config(mapOfRequiredArtifacts, false);
		addon.add(systemPackage("javax.xml.parsers"));
		addon.add(0, packApamConflictManager());
		return addon;

	}

	@Test
	public void FetchImplThatHasComposite_tc029() {

		CompositeType ct1 = (CompositeType) waitForComponentByName(null,
				"S2Impl-composite-1");

		// apam.waitForIt(2000);

		CompositeType ct2 = (CompositeType) waitForImplByName(null,
				"S2Impl-composite-2");

		String general = "From two composites based on the same impl, both should be fetchable/instantiable from apam. %s";

		Assert.assertTrue(
				String.format(general, "The first one failed to be fetched."),
				ct1 != null);
		Assert.assertTrue(
				String.format(general, "The second one failed to be fetched."),
				ct2 != null);

		Instance ip1 = ct1.createInstance(null, new HashMap<String, String>());
		Instance ip2 = ct2.createInstance(null, new HashMap<String, String>());

		Assert.assertTrue(
				String.format(general, "The first one failed to instantiate."),
				ip1 != null);
		Assert.assertTrue(
				String.format(general, "The second one failed to instantiate."),
				ip2 != null);

		System.err.println("-------------");
		auxListInstances("\t");

	}

	@Test
	public void compositeWithMainImplem_tct034() {

		CompositeType compo = (CompositeType) waitForComponentByName(null,"compositeWithMainImplem_tct034");
		Component created = null;
		
		if (compo != null) {
			created = compo.createInstance(null, null);
		}
		
		auxListInstances();

		Assert.assertTrue(
				"Composite should be created when main implem in another bundle",
				created != null);
	}

	class InstanceCreator extends Thread {

		String myCompositeName;
		public Instance created;

		public InstanceCreator(String compositeName) {
			myCompositeName = compositeName;
			created = null;
		}

		@Override
		public void run() {
		}
	}
}