/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.resolver.tests;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.osgi.service.resolver.BaseDescription;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.PlatformAdmin;
import org.eclipse.osgi.service.resolver.ResolverError;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.osgi.service.resolver.StateObjectFactory;
import org.eclipse.osgi.service.resolver.VersionConstraint;
import org.eclipse.osgi.service.resolver.extras.DescriptionReference;
import org.eclipse.osgi.service.resolver.extras.SpecificationReference;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.resource.Capability;
import org.osgi.framework.resource.Requirement;
import org.osgi.framework.resource.Resource;
import org.osgi.framework.resource.Wire;
import org.osgi.framework.wiring.BundleCapability;
import org.osgi.framework.wiring.BundleRevision;
import org.osgi.framework.wiring.BundleWiring;
import org.osgi.service.resolver.Environment;
import org.osgi.service.resolver.Resolver;

public class ResolverTest extends TestCase {

	private Resolver resolver;
	private ServiceReference<Resolver> resolverRef;
	private PlatformAdmin platformAdmin;
	private ServiceReference<PlatformAdmin> platformAdminRef;

	protected void setUp() throws Exception {
		Activator.getBundle(Activator.BUNDLE_RESOLVER).start();
		resolverRef = Activator.getBundleContext().getServiceReference(Resolver.class);
		resolver = Activator.getBundleContext().getService(resolverRef);
		assertNotNull("No resolver service.", resolver); //$NON-NLS-1$
		platformAdminRef = Activator.getBundleContext().getServiceReference(PlatformAdmin.class);
		platformAdmin = Activator.getBundleContext().getService(platformAdminRef);
		assertNotNull("No platformadmin service.", resolver); //$NON-NLS-1$
	}

	protected void tearDown() throws Exception {
		Activator.getBundleContext().ungetService(resolverRef);
		Activator.getBundleContext().ungetService(platformAdminRef);
		Activator.getBundle(Activator.BUNDLE_RESOLVER).stop();
	}

	private Map<String, Map<String, List<BaseDescription>>> getRepository(List<? extends BundleRevision> bundles) {
		Map<String, Map<String, List<BaseDescription>>> repository = new HashMap<String, Map<String,List<BaseDescription>>>();
		for (BundleRevision revision : bundles) {
			List<BundleCapability> capabilities = revision.getDeclaredCapabilities(null);
			for (BundleCapability capability : capabilities) {
				BaseDescription description = ((DescriptionReference) capability).getDescription();
				Map<String, List<BaseDescription>> namespace = repository.get(capability.getNamespace());
				if (namespace == null) {
					namespace = new HashMap<String, List<BaseDescription>>(2);
					repository.put(capability.getNamespace(), namespace);
				}
				List<BaseDescription> repoCapabilities = namespace.get(description.getName());
				if (repoCapabilities == null) {
					repoCapabilities = new ArrayList<BaseDescription>(2);
					namespace.put(description.getName(), repoCapabilities);
				}
				repoCapabilities.add(description);
				if (repoCapabilities.size() > 1) {
					Collections.sort(repoCapabilities, new Comparator<BaseDescription>() {
						public int compare(BaseDescription d1, BaseDescription d2) {
								String systemBundle = "org.eclipse.osgi";
								if (systemBundle.equals(d1.getSupplier().getSymbolicName()) && !systemBundle.equals(d2.getSupplier().getSymbolicName()))
									return -1;
								else if (!systemBundle.equals(d1.getSupplier().getSymbolicName()) && systemBundle.equals(d2.getSupplier().getSymbolicName()))
									return 1;
							if (d1.getSupplier().isResolved() != d2.getSupplier().isResolved())
								return d1.getSupplier().isResolved() ? -1 : 1;
							int versionCompare = -(d1.getVersion().compareTo(d2.getVersion()));
							if (versionCompare != 0)
								return versionCompare;
							return d1.getSupplier().getBundleId() <= d2.getSupplier().getBundleId() ? -1 : 1;
						}
					});
				}
			}
		}
		return repository;
	}

	@SuppressWarnings("unchecked")
	private void getRequirementsRevsionsWiring(List<BundleRevision> revisions, Map<Resource, List<Wire>> wiring) {
		Bundle[] bundles = Activator.getBundleContext().getBundles();
		bundlesLoop: for (Bundle bundle : bundles) {
			BundleRevision revision = bundle.adapt(BundleRevision.class);
			BundleDescription description = (BundleDescription) revision;
			if (!description.isResolved()) {
				// check the ee
				description.getContainingState().resolve(new BundleDescription[] {description}, false);
				ResolverError[] errors = description.getContainingState().getResolverErrors(description);
				for (ResolverError resolverError : errors) {
					if (resolverError.getType() == ResolverError.PLATFORM_FILTER)
						continue bundlesLoop;
				}
			}
			revisions.add(revision);
			BundleWiring bundleWiring = revision.getWiring();
			if (bundleWiring != null) {
				List<? extends Wire> wires = bundleWiring.getRequiredWires(null);
				wiring.put(revision, (List<Wire>) wires);
			}
		}
	}

	@SuppressWarnings("unchecked")
	private Map<Resource, List<Wire>> getWiring(List<BundleDescription> revisions) {
		State state = platformAdmin.getFactory().createState(true);
		for (BundleDescription bundle : revisions) {
			if (bundle.getContainingState() != null)
				throw new IllegalArgumentException("Bundle already in a state: " + bundle);
			state.addBundle(bundle);
		}
		state.resolve();
		Map<Resource, List<Wire>> result = new HashMap<Resource, List<Wire>>();
		for (BundleDescription bundle : revisions) {
			BundleWiring bundleWiring = bundle.getWiring();
			if (bundleWiring != null) {
				List<? extends Wire> wires = bundleWiring.getRequiredWires(null);
				result.put(bundle, (List<Wire>) wires);
			}
		}
		return result;
	}

	private void compareWirings(Map<Resource, List<Wire>> expected,
			Map<Resource, List<Wire>> actual) {
		assertEquals("Wrong number of bundles got resolved.", expected.size(), actual.size());
		for (Map.Entry<Resource, List<Wire>> resourceEntry : expected.entrySet()) {
			List<Wire> expectedWires = resourceEntry.getValue();
			List<Wire> actualWires = actual.get(resourceEntry.getKey());
			assertNotNull("No wires found for: " + resourceEntry.getKey(), actualWires);
			for (Wire expectedWire : expectedWires) {
				boolean found = false;
				for (Wire actualWire : actualWires) {
					boolean sameProvider = expectedWire.getProvider().equals(actualWire.getProvider());
					boolean sameCapability = expectedWire.getCapability().equals(actualWire.getCapability());
					boolean sameRequirer = expectedWire.getRequirer().equals(actualWire.getRequirer());
					boolean sameRequirement = expectedWire.getRequirement().equals(actualWire.getRequirement());
					found = sameProvider && sameCapability && sameRequirer && sameRequirement;
					if (found)
						break;
				}
				if (!found)
					fail("Failed to find expected wire: " + expectedWire);
			}
		}
	}

	public void testResolverService01() {
		List<BundleRevision> revisions = new ArrayList<BundleRevision>();
		Map<Resource, List<Wire>> wiring = new HashMap<Resource, List<Wire>>();
		getRequirementsRevsionsWiring(revisions, wiring);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), null, revisions);

		System.out.println("Number of bundles currently resolved: " + wiring.size());
		System.out.println("Number of bundles to resolve: " + revisions.size());
		System.out.println("Number of bundles that got resolved: " + result.size());

		compareWirings(wiring, result);
	}

	public void testResolverService02() {
		List<BundleRevision> revisions = new ArrayList<BundleRevision>();
		Map<Resource, List<Wire>> wiring = new HashMap<Resource, List<Wire>>();
		getRequirementsRevsionsWiring(revisions, wiring);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(wiring, repository), null, revisions);

		System.out.println("Number of bundles currently resolved: " + wiring.size());
		System.out.println("Number of bundles to resolve: " + revisions.size());
		System.out.println("Number of bundles that got resolved: " + result.size());

		assertEquals("Wrong number of bundles got resolved.", 0, result.size());
	}

	public void testResolverServiceImportPackage() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleDescription> revisions = new ArrayList<BundleDescription>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.IMPORT_PACKAGE, "b, c");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b");
		BundleDescription b = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription c = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(c);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), Arrays.asList(a), null);

		Map<Resource, List<Wire>> expectedWiring = getWiring(revisions);
		compareWirings(expectedWiring, result);
		dumpResults(result);
	}

	public void testResolverServiceFragmentHost1() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleDescription> revisions = new ArrayList<BundleDescription>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.IMPORT_PACKAGE, "b, c");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		BundleDescription b = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "BFrag");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.FRAGMENT_HOST, "B");
		manifest.put(Constants.EXPORT_PACKAGE, "b");
		BundleDescription bFrag = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(bFrag);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		BundleDescription c = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(c);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "CFrag");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.FRAGMENT_HOST, "C");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription cFrag = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(cFrag);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), Arrays.asList(a), null);

		Map<Resource, List<Wire>> expectedWiring = getWiring(revisions);
		compareWirings(expectedWiring, result);
		dumpResults(result);
	}

	public void testResolverServiceFragmentHost2() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleDescription> revisions = new ArrayList<BundleDescription>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.IMPORT_PACKAGE, "b.frag, b; v=1");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b; version=1.0; v=1");
		BundleDescription b1 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b1);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "2.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b; version=1.0; v=2");
		BundleDescription b2 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b2);


		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "BFrag");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.FRAGMENT_HOST, "B; multiple-hosts:=true");
		manifest.put(Constants.EXPORT_PACKAGE, "b.frag; uses:=b");
		BundleDescription bFrag = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(bFrag);


		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), Arrays.asList(a), null);

		Map<Resource, List<Wire>> expectedWiring = getWiring(revisions);
		compareWirings(expectedWiring, result);
		dumpResults(result);
	}

	public void testResolverServiceRequireBundle() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleDescription> revisions = new ArrayList<BundleDescription>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.REQUIRE_BUNDLE, "B, C");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b");
		BundleDescription b = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription c = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(c);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), Arrays.asList(a), null);
		
		Map<Resource, List<Wire>> expectedWiring = getWiring(revisions);
		compareWirings(expectedWiring, result);
		dumpResults(result);
	}

	public void testResolverServiceRequireCapability() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleRevision> revisions = new ArrayList<BundleRevision>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.REQUIRE_CAPABILITY, "B; filter:=\"(B=b)\", C; filter:=\"(C=c)\"");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.PROVIDE_CAPABILITY, "B; B=b");
		BundleDescription b = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(b);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.PROVIDE_CAPABILITY, "C; C=c");
		BundleDescription c = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(c);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository), Arrays.asList(a), null);
		dumpResults(result);
	}


	private void dumpResults(Map<Resource, List<Wire>> result) {
		System.out.println("TestCase: " + getName());
		for (Map.Entry<Resource, List<Wire>> entry : result.entrySet()) {
			System.out.println(" " + entry.getKey());
			for (Wire wire : entry.getValue()) {
				System.out.println("  " + wire);
			}
		}
	}

	public void testResolverPreferenceOrder() throws BundleException {
		StateObjectFactory factory = platformAdmin.getFactory();
		int id = 0;		
		List<BundleDescription> revisions = new ArrayList<BundleDescription>();
		Hashtable<String, String> manifest = new Hashtable<String, String>();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "A");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.IMPORT_PACKAGE, "b");
		manifest.put(Constants.REQUIRE_BUNDLE, "C");
		manifest.put(Constants.REQUIRE_CAPABILITY, "D; filter:=\"(D=d)\"");
		BundleDescription a = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(a);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "3.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b; version=3.0");
		BundleDescription b3 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(b3);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "2.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b; version=2.0");
		BundleDescription b2 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(b2);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "B");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "b; version=1.0");
		BundleDescription b1 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(b1);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "3.0");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription c3 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(c3);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "2.0");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription c2 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(c2);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "C");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.EXPORT_PACKAGE, "c");
		BundleDescription c1 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME) + manifest.get(Constants.BUNDLE_VERSION), id++);
		revisions.add(c1);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "D");
		manifest.put(Constants.BUNDLE_VERSION, "3.0");
		manifest.put(Constants.PROVIDE_CAPABILITY, "D; D=d; version:Version=\"3.0\"");
		BundleDescription d3 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(d3);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "D");
		manifest.put(Constants.BUNDLE_VERSION, "2.0");
		manifest.put(Constants.PROVIDE_CAPABILITY, "D; D=d; version:Version=\"2.0\"");
		BundleDescription d2 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(d2);

		manifest.clear();
		manifest.put(Constants.BUNDLE_MANIFESTVERSION, "2");
		manifest.put(Constants.BUNDLE_SYMBOLICNAME, "D");
		manifest.put(Constants.BUNDLE_VERSION, "1.0");
		manifest.put(Constants.PROVIDE_CAPABILITY, "D; D=d; version:Version=\"1.0\"");
		BundleDescription d1 = factory.createBundleDescription(null, manifest, manifest.get(Constants.BUNDLE_SYMBOLICNAME), id++);
		revisions.add(d1);

		Map<String, Map<String, List<BaseDescription>>> repository = getRepository(revisions);
		Map<Resource, List<Wire>> result = resolver.resolve(new TestEnvironment(null, repository, true), Arrays.asList(a), null);

		Map<Resource, List<Wire>> expectedWiring = getWiring(revisions);
		dumpResults(result);
		compareWirings(expectedWiring, result);
	}

	
	class TestEnvironment implements Environment {
		private final Map<Resource, List<Wire>> wiring;
		private final Map<String, Map<String, List<BaseDescription>>> repository;
		private final boolean reverseCandidates;
		public TestEnvironment(Map<Resource, List<Wire>> wiring, Map<String, Map<String, List<BaseDescription>>> repository) {
			this(wiring, repository, false);
		}

		public TestEnvironment(Map<Resource, List<Wire>> wiring, Map<String, Map<String, List<BaseDescription>>> repository, boolean reverseCandidates) {
			this.wiring = wiring;
			this.repository = repository;
			this.reverseCandidates = reverseCandidates;
		}

		public boolean isEffective(Requirement requirement) throws NullPointerException {
			return true;
		}

		public Map<Resource, List<Wire>> getWiring() {
			if (wiring == null)
				return Collections.emptyMap();
			else
				return wiring;
		}

		public Collection<Capability> findProviders(Requirement requirement) throws NullPointerException {
			List<Capability> result = new ArrayList<Capability>();
			Map<String, List<BaseDescription>> namespace = repository.get(requirement.getNamespace());
			VersionConstraint specification = ((SpecificationReference) requirement).getSpecification();
			String name = specification.getName();
			List<BaseDescription> candidates;
			if (name == null || name.indexOf('*') > -1) {
				candidates = new ArrayList<BaseDescription>();
				for (List<BaseDescription> baseDescriptions : namespace.values()) {
					candidates.addAll(baseDescriptions);
				}
			} else {
				candidates = namespace.get(name);
			}
			if (candidates != null) {
				for (BaseDescription baseDescription : candidates) {
					if (BundleRevision.HOST_NAMESPACE.equals(requirement.getNamespace())) {
						result.addAll(baseDescription.getSupplier().getCapabilities(BundleRevision.HOST_NAMESPACE));
					} else {
						result.add(baseDescription.getCapability());
					}
				}
			}
			if (reverseCandidates)
				Collections.reverse(result);
			return result;
		}
	}
}