/*******************************************************************************
 * Copyright (c) 2010 The Eclipse Foundation 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:
 *     The Eclipse Foundation - initial API and implementation
 *******************************************************************************/
package org.eclipse.epp.mpc.tests.service;

import static org.hamcrest.Matchers.*;
import static org.junit.Assume.*;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.cert.Certificate;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.epp.internal.mpc.core.MarketplaceClientCore;
import org.eclipse.epp.internal.mpc.core.MarketplaceClientCorePlugin;
import org.eclipse.epp.internal.mpc.core.ServiceLocator;
import org.eclipse.epp.internal.mpc.core.service.DefaultMarketplaceService;
import org.eclipse.epp.mpc.core.model.IIu;
import org.eclipse.epp.mpc.core.model.IIus;
import org.eclipse.epp.mpc.core.model.INode;
import org.eclipse.epp.mpc.core.model.ISearchResult;
import org.eclipse.epp.mpc.core.service.IMarketplaceUnmarshaller;
import org.eclipse.epp.mpc.core.service.QueryHelper;
import org.eclipse.epp.mpc.core.service.UnmarshalException;
import org.eclipse.epp.mpc.tests.Categories.RemoteTests;
import org.eclipse.epp.mpc.tests.LoggingSuite;
import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper;
import org.eclipse.equinox.internal.p2.repository.Activator;
import org.eclipse.equinox.p2.core.IProvisioningAgent;
import org.eclipse.equinox.p2.core.UIServices;
import org.hamcrest.Matcher;
import org.hamcrest.MatcherAssert;
import org.junit.Assert;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.ComparisonFailure;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.rules.ExternalResource;
import org.junit.rules.TestRule;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.model.Statement;
import org.osgi.framework.ServiceRegistration;

@RunWith(Parameterized.class)
@Category(RemoteTests.class)
@Ignore("Disabled until test data on marketplace-staging.eclipse.org can be recreated")
public class SolutionCompatibilityFilterTest {
	private static final String BASE_URL = "http://marketplace-staging.eclipse.org";

	public static enum System {
		WIN32(Platform.OS_WIN32, Platform.WS_WIN32), //
		LINUX(Platform.OS_LINUX, Platform.WS_GTK), //
		MACOS(Platform.OS_MACOSX, Platform.WS_COCOA);

		private final String os;

		private final String ws;

		private System(String os, String ws) {
			this.os = os;
			this.ws = ws;
		}

		public void applyTo(Map<String, String> metaParams) {
			metaParams.put(DefaultMarketplaceService.META_PARAM_OS, os);
			metaParams.put(DefaultMarketplaceService.META_PARAM_WS, ws);
		}
	}

	private static final String JAVA_PRODUCT_ID = "epp.package.java";

	private static final String SDK_PRODUCT_ID = "org.eclipse.sdk.ide";

	public static enum EclipseRelease {
		UNKNOWN(null, null, null, null), //
		INDIGO(JAVA_PRODUCT_ID, "1.4.2.20120131-1457", "3.7.0.v20110110", null), //
		JUNO_3_8(SDK_PRODUCT_ID, "3.8.0.v201206081200", "3.8.0.v20120521-2346", null), //
		JUNO_3_8_WITH_PLATFORM(SDK_PRODUCT_ID, JUNO_3_8.productVersion(), JUNO_3_8.runtimeVersion(),
				"3.8.0.v201206081200"), //
		JUNO(JAVA_PRODUCT_ID, "1.5.0.20120131-1544", "3.8.0.v20120521-2346", null), //
		JUNO_WITH_PLATFORM(JAVA_PRODUCT_ID, JUNO.productVersion(), JUNO.runtimeVersion(), "4.2.0.v201206081400"), //
		JUNO_SR2(JAVA_PRODUCT_ID, "1.5.2.20130110-1126", "3.8.0.v20120521-2346", "4.2.2.v201302041200"), //
		KEPLER(JAVA_PRODUCT_ID, "2.0.0.20130613-0530", "3.9.0.v20130326-1255", "4.3.0.v20130605-2000"), //
		KEPLER_SR2(JAVA_PRODUCT_ID, "2.0.2.20140224-0000", "3.9.100.v20131218-1515", "4.3.2.v20140221-1700"), //
		LUNA(JAVA_PRODUCT_ID, "4.4.0.20140612-0500", "3.10.0.v20140318-2214", "4.4.0.v20140606-1215"), //
		LUNA_SR2(JAVA_PRODUCT_ID, "4.4.2.20150219-0708", "3.10.0.v20140318-2214", "4.4.2.v20150204-1700"), //
		MARS(JAVA_PRODUCT_ID, "4.5.0.20150326-0704", "3.10.0.v20150112-1422", "4.5.0.v20150203-1300");

		private final String productId;

		private final String productVersion;

		private final String runtimeVersion;

		private final String platformVersion;

		private EclipseRelease(String productId, String productVersion, String runtimeVersion, String platformVersion) {
			this.productId = productId;
			this.productVersion = productVersion;
			this.runtimeVersion = runtimeVersion;
			this.platformVersion = platformVersion;
		}

		private EclipseRelease(String productVersion, String runtimeVersion, String platformVersion) {
			this(JAVA_PRODUCT_ID, productVersion, runtimeVersion, platformVersion);
		}

		public String productId() {
			return productId;
		}

		public String productVersion() {
			return productVersion;
		}

		public String runtimeVersion() {
			return runtimeVersion;
		}

		public String platformVersion() {
			return platformVersion;
		}

		public void applyTo(Map<String, String> metaParams) {
			if (productVersion == null) {
				metaParams.remove(DefaultMarketplaceService.META_PARAM_PRODUCT);
				metaParams.remove(DefaultMarketplaceService.META_PARAM_PRODUCT_VERSION);
			} else {
				metaParams.put(DefaultMarketplaceService.META_PARAM_PRODUCT, productId);
				metaParams.put(DefaultMarketplaceService.META_PARAM_PRODUCT_VERSION, productVersion);
			}
			if (runtimeVersion == null) {
				metaParams.remove(DefaultMarketplaceService.META_PARAM_RUNTIME_VERSION);
			} else {
				metaParams.put(DefaultMarketplaceService.META_PARAM_RUNTIME_VERSION, runtimeVersion);
			}
			if (platformVersion == null) {
				metaParams.remove(DefaultMarketplaceService.META_PARAM_PLATFORM_VERSION);
			} else {
				metaParams.put(DefaultMarketplaceService.META_PARAM_PLATFORM_VERSION, platformVersion);
			}
		}

		public static EclipseRelease previous(EclipseRelease release) {
			if (release == UNKNOWN) {
				return null;
			}
			int previousOrdinal = release.ordinal() - 1;
			return previousOrdinal > UNKNOWN.ordinal() ? values()[previousOrdinal] : null;
		}

		public static EclipseRelease next(EclipseRelease release) {
			if (release == UNKNOWN) {
				return null;
			}
			int nextOrdinal = release.ordinal() + 1;
			return values().length > nextOrdinal ? values()[nextOrdinal] : null;
		}
	}

	public static enum Solution {
		JUNO("test-entry-juno", EclipseRelease.JUNO_3_8, EclipseRelease.JUNO_SR2), //
		KEPLER("test-entry-kepler", EclipseRelease.KEPLER, EclipseRelease.KEPLER_SR2), //
		LUNA("test-entry-luna", EclipseRelease.LUNA, EclipseRelease.LUNA_SR2), //
		MARS("test-entry-mars", EclipseRelease.MARS, EclipseRelease.MARS), //
		JUNO_AND_EARLIER("test-entry-juno-and-earlier", null, EclipseRelease.JUNO_SR2), //
		KEPLER_AND_EARLIER("test-entry-kepler-and-earlier", null, EclipseRelease.KEPLER_SR2), //
		KEPLER_LUNA("test-entry-kepler-luna", EclipseRelease.KEPLER, EclipseRelease.LUNA_SR2), //
		KEPLER_MARS("test-entry-kepler-luna-mars", EclipseRelease.KEPLER, EclipseRelease.MARS), //
		LUNA_WIN32("test-entry-luna-win32", EclipseRelease.LUNA, EclipseRelease.LUNA_SR2, System.WIN32), //
		LUNA_LINUX_MACOS("test-entry-luna-mac-linux", EclipseRelease.LUNA, EclipseRelease.LUNA_SR2, System.LINUX,
				System.MACOS), //
		MULTI_VERSION("test-entry-multi-version", null, EclipseRelease.MARS), //
		PSEUDO_CONFLICT("test-entry-pseudo-conflict", EclipseRelease.KEPLER, EclipseRelease.MARS), //
		CONFLICT("test-entry-conflict", EclipseRelease.KEPLER, EclipseRelease.MARS), //
		UNINSTALLABLE(""/* TODO */, null, null, System.WIN32, System.MACOS, System.LINUX);

		private final String id;

		private final String shortName;

		private final EclipseRelease minRelease;

		private final EclipseRelease maxRelease;

		private final System[] systems;

		private Solution(String shortName, EclipseRelease minRelease, EclipseRelease maxRelease, System... systems) {
			this.id = null;
			this.shortName = shortName;
			this.minRelease = minRelease;
			this.maxRelease = maxRelease;
			this.systems = systems;
		}

		public String id() {
			return id;
		}

		public String shortName() {
			return shortName;
		}

		public String url() {
			return BASE_URL + "/content/" + shortName;
		}

		public String query() {
			return shortName;
		}

		public boolean installable() {
			//TODO
			return true;
		}

		public EclipseRelease minRelease() {
			return minRelease;
		}

		public EclipseRelease maxRelease() {
			return maxRelease;
		}

		public System[] systems() {
			return systems == null || systems.length == 0 ? System.values() : systems;
		}

		public boolean isCompatible(System system) {
			if (systems == null || system == null) {
				return true;
			}
			for (System aSystem : systems()) {
				if (aSystem == system) {
					return true;
				}
			}
			return false;
		}

		public boolean isCompatible(EclipseRelease release) {
			if (release == EclipseRelease.UNKNOWN) {
				return true;
			}
			if (minRelease() != null) {
				if (minRelease().ordinal() > release.ordinal()) {
					return false;
				}
			}
			if (maxRelease() != null) {
				if (maxRelease().ordinal() < release.ordinal()) {
					return false;
				}
			}
			return true;
		}
	}

	@Parameters(name = "{index}__{0}__with__{1}_{2}")
	public static Iterable<Object[]> data() {
		List<Object[]> data = new ArrayList<Object[]>();
		checkSolutionReleaseBounds(data, Solution.JUNO);
		checkSolutionReleaseBounds(data, Solution.KEPLER);
		checkSolutionReleaseBounds(data, Solution.LUNA);
		checkSolutionReleaseBounds(data, Solution.MARS);

		//bug 466627
		checkSolutionWithEclipse(data, "Solution should not be installable in an older release", Solution.MARS,
				EclipseRelease.INDIGO, null);
		checkSolutionWithEclipse(data, "Solution should not be installable in an older release", Solution.MARS,
				EclipseRelease.JUNO_3_8, null);
		checkSolutionWithEclipse(data, "Solution should not be installable in an older release", Solution.MARS,
				EclipseRelease.JUNO, null);

		checkSolutionReleaseBounds(data, Solution.JUNO_AND_EARLIER);
		checkSolutionReleaseBounds(data, Solution.KEPLER_AND_EARLIER);
		checkSolutionReleaseBounds(data, Solution.KEPLER_LUNA);

		checkSolutionData(data, "Solution should have version 1.0.0 features for Kepler release", Solution.KEPLER_LUNA,
				EclipseRelease.KEPLER, System.WIN32, "1.0.0", "http://example.org/kepler", "org.example.feature.kepler");
		checkSolutionData(data, "Solution should have version 1.1.0 features for Luna release", Solution.KEPLER_LUNA,
				EclipseRelease.LUNA, System.WIN32, "1.1.0", "http://example.org/luna", "org.example.feature.luna");
		checkSolutionReleaseBounds(data, Solution.KEPLER_MARS);
		checkSolutionData(data, "Solution should have version 1.0.0 features for Kepler release", Solution.KEPLER_MARS,
				EclipseRelease.KEPLER, System.WIN32, "1.0.0", "http://example.org/kepler-luna",
				"org.example.feature.kepler.luna");
		checkSolutionData(data, "Solution should have version 1.0.0 features for Luna release", Solution.KEPLER_MARS,
				EclipseRelease.LUNA, System.WIN32, "1.0.0", "http://example.org/kepler-luna",
				"org.example.feature.kepler.luna");
		checkSolutionData(data, "Solution should have version 1.1.0 features for Mars release", Solution.KEPLER_MARS,
				EclipseRelease.MARS, System.WIN32, "1.1.0", "http://example.org/mars", "org.example.feature.mars");
		checkSolutionWithEclipse(data, "Solution should be installable in a compatible release and os",
				Solution.LUNA_WIN32, EclipseRelease.LUNA, System.WIN32);
		checkSolutionWithEclipse(data, "Solution should not be installable in an incompatible os", Solution.LUNA_WIN32,
				EclipseRelease.LUNA, System.LINUX);
		checkSolutionWithEclipse(data, "Solution should not be installable in an older release", Solution.LUNA_WIN32,
				EclipseRelease.KEPLER, System.WIN32);
		checkSolutionWithEclipse(data, "Solution should not be installable in an older release and incompatible os",
				Solution.LUNA_WIN32, EclipseRelease.KEPLER, System.LINUX);
		checkSolutionWithEclipse(data, "Solution should not be installable in a newer release", Solution.LUNA_WIN32,
				EclipseRelease.MARS, System.WIN32);
		checkSolutionWithEclipse(data, "Solution should not be installable in a newer release and incompatible os",
				Solution.LUNA_WIN32, EclipseRelease.MARS, System.LINUX);
		checkSolutionWithEclipse(data, "Solution should be installable in a compatible release and os",
				Solution.LUNA_LINUX_MACOS, EclipseRelease.LUNA, System.LINUX);
		checkSolutionWithEclipse(data, "Solution should be installable in a compatible release and os",
				Solution.LUNA_LINUX_MACOS, EclipseRelease.LUNA, System.MACOS);
		checkSolutionWithEclipse(data, "Solution should not installable in an incompatible os",
				Solution.LUNA_LINUX_MACOS, EclipseRelease.LUNA, System.WIN32);
		checkSolutionData(data, "Solution should have version 1.1.0 features for Juno release", Solution.MULTI_VERSION,
				EclipseRelease.JUNO, System.LINUX, "1.1.0", "http://example.org/juno-kepler",
				"org.example.feature.juno.kepler");
		checkSolutionData(data, "Solution should have version 1.1.0 features for Kepler release",
				Solution.MULTI_VERSION, EclipseRelease.KEPLER, System.MACOS, "1.1.0", "http://example.org/juno-kepler",
				"org.example.feature.juno.kepler");
		checkSolutionData(data, "Solution should have version 1.1.1 features for Kepler release on Windows",
				Solution.MULTI_VERSION, EclipseRelease.KEPLER, System.WIN32, "1.1.1",
				"http://example.org/juno-kepler-win32", "org.example.feature.juno.kepler.win32");
		checkSolutionData(data, "Solution should have version 1.2.0 features for Luna release", Solution.MULTI_VERSION,
				EclipseRelease.LUNA, System.WIN32, "1.2.0", "http://example.org/luna",
				"org.example.feature.luna.nolinux");
		checkSolutionWithEclipse(data, "Solution should be incompatible with Linux for Luna release",
				Solution.MULTI_VERSION, EclipseRelease.LUNA, System.LINUX, false);
		checkSolutionData(data, "Solution should have version 1.3.0 features for Mars release", Solution.MULTI_VERSION,
				EclipseRelease.MARS, System.MACOS, "1.3.0", "http://example.org/mars",
				"org.example.feature.mars.nolinux");
		checkSolutionWithEclipse(data, "Solution should be incompatible with Linux for Mars release",
				Solution.MULTI_VERSION, EclipseRelease.MARS, System.LINUX, false);
		checkSolutionData(
				data,
				"Solution with overlapping versions but separate os (pseudo-conflict) should have version 1.0.0 for Luna on Mac",
				Solution.PSEUDO_CONFLICT, EclipseRelease.LUNA, System.MACOS, "1.0.0", "http://example.org/maclinux",
				"org.example.feature.maclinux");
		checkSolutionData(
				data,
				"Solution with overlapping versions but separate os (pseudo-conflict) should have version 1.1.0 for Luna on Windows",
				Solution.PSEUDO_CONFLICT, EclipseRelease.LUNA, System.WIN32, "1.1.0", "http://example.org/win",
				"org.example.feature.win");
		checkSolutionData(
				data,
				"Solution with overlapping versions (real conflict) should have correct version for non-overlapping release (older version)",
				Solution.CONFLICT, EclipseRelease.KEPLER, System.WIN32, "1.0.0", "http://example.org/kepler-luna",
				"org.example.feature.keplerluna");
		checkSolutionData(
				data,
				"Solution with overlapping versions (real conflict) should have latest version for overlapping release",
				Solution.CONFLICT, EclipseRelease.LUNA, System.WIN32, "1.1.0", "http://example.org/luna-mars",
				"org.example.feature.lunamars");
		checkSolutionData(
				data,
				"Solution with overlapping versions (real conflict) should have latest version for overlapping release",
				Solution.CONFLICT, EclipseRelease.LUNA, System.MACOS, "1.1.0", "http://example.org/luna-mars",
				"org.example.feature.lunamars");
		checkSolutionData(
				data,
				"Solution with overlapping versions (real conflict) should have correct version for non-overlapping release (newer version)",
				Solution.CONFLICT, EclipseRelease.MARS, System.WIN32, "1.1.0", "http://example.org/luna-mars",
				"org.example.feature.lunamars");
		//		checkSolutionWithEclipse(data, Solution.UNINSTALLABLE, EclipseRelease.UNKNOWN, System.WIN32);
		//		checkSolutionWithEclipse(data, Solution.UNINSTALLABLE, EclipseRelease.UNKNOWN, System.LINUX);
		//		checkSolutionWithEclipse(data, Solution.UNINSTALLABLE, EclipseRelease.UNKNOWN, System.MACOS);
		return data;
	}

	private static void checkSolutionData(List<Object[]> data, String testDescription, Solution solution,
			EclipseRelease release, System system, String version, String site, String... features) {
		if (release == null) {
			release = EclipseRelease.UNKNOWN;
		}
		if (system == null) {
			system = System.WIN32;
		}

		boolean releaseCompatible = solution.isCompatible(release);
		boolean systemCompatible = solution.isCompatible(system);
		boolean compatible = releaseCompatible && systemCompatible;

		checkSolutionData(data, testDescription, solution, release, system, compatible, version, site, features);
	}

	private static void checkSolutionData(List<Object[]> data, String testDescription, Solution solution,
			EclipseRelease release, System system, boolean compatible, String version, String site, String... features) {
		if (release == null) {
			release = EclipseRelease.UNKNOWN;
		}
		if (system == null) {
			system = System.WIN32;
		}
		if (features != null && features.length == 0) {
			features = null;
		}

		for (Object[] objects : data) {
			if (objects[0] == solution && objects[1] == release && objects[2] == system) {
				if (((version == null && objects[3] == null) || (version != null && version.equals(objects[3])))
						&& ((site == null && objects[4] == null) || (site != null && site.equals(objects[4])))) {
					if (features == null && objects[5] == null) {
						return;
					}
					Set<String> allFeatures = new HashSet<String>(Arrays.asList(features));
					Set<String> allDataFeatures = new HashSet<String>(Arrays.asList((String[]) objects[5]));
					if (allFeatures.equals(allDataFeatures)) {
						return;
					}
				}
			}
		}
		data.add(new Object[] { solution, release, system, version, site, features, compatible, testDescription });
	}

	private static void checkSolutionReleaseBounds(List<Object[]> data, Solution solution) {
		EclipseRelease minRelease = solution.minRelease();
		EclipseRelease maxRelease = solution.maxRelease();
		EclipseRelease beforeMin = minRelease == null ? null : EclipseRelease.previous(minRelease);
		EclipseRelease afterMax = maxRelease == null ? null : EclipseRelease.next(maxRelease);
		if (beforeMin != null) {
			checkSolutionWithEclipse(data, "Solution should not be installable in an older release", solution,
					beforeMin, null);
		}
		for (EclipseRelease release : EclipseRelease.values()) {
			if (solution.isCompatible(release)) {
				checkSolutionWithEclipse(data, "Solution should be installable in a compatible release", solution,
						release, null);
			}
		}
		checkSolutionWithEclipse(data, "Solution should be installable in an unknown release", solution,
				EclipseRelease.UNKNOWN, null);
		if (afterMax != null) {
			checkSolutionWithEclipse(data, "Solution should not be installable in a newer release", solution, afterMax,
					null);
		}
	}

	private static void checkSolutionWithEclipse(List<Object[]> data, String testDescription, Solution solution,
			EclipseRelease release, System system) {
		checkSolutionData(data, testDescription, solution, release, system, null, null);
	}

	private static void checkSolutionWithEclipse(List<Object[]> data, String testDescription, Solution solution,
			EclipseRelease release, System system, boolean compatible) {
		checkSolutionData(data, testDescription, solution, release, system, compatible, null, null);
	}

	private static void assertTrue(String message, boolean b, Object... details) {
		Assert.assertTrue(format(message, flatten(b, details)), b);
	}

	private static void assertNotNull(Object value) {
		Assert.assertNotNull(value);
	}

	private static void assertEquals(String message, Object o1, Object o2, Object... details) {
		Assert.assertEquals(format(message, flatten(o1, o2, details)), o1, o2);
	}

	private static void assertNotNull(String message, Object value, Object... details) {
		Assert.assertNotNull(format(message, flatten(value, details)), value);
	}

	private static <T> void assertThat(String reason, T actual, Matcher<? super T> matcher, Object... details) {
		MatcherAssert.assertThat(format(reason, flatten(actual, details)), actual, matcher);
	}

	private static void assertNull(String message, Object value, Object... details) {
		Assert.assertNull(format(message, flatten(value, details)), value);
	}

	private static String format(String message, Object... details) {
		if (details == null || details.length == 0) {
			return message;
		}

		String contentPrefix = BASE_URL + "/content/";
		for (int i = 0; i < details.length; i++) {
			Object detail = details[i];
			if (detail instanceof INode) {
				INode node = (INode) detail;
				String url = node.getUrl();
				if (url != null) {
					if (url.startsWith(contentPrefix)) {
						String shortName = url.substring(contentPrefix.length());
						detail = shortName;
					} else {
						detail = url;
					}
				} else {
					detail = node.getId();
				}
			} else if (detail instanceof Solution) {
				Solution solution = (Solution) detail;
				detail = solution.shortName();
			}
			details[i] = detail;
		}
		return MessageFormat.format(message, details);
	}

	private static Object[] flatten(Object... values) {
		List<Object> flattened = new ArrayList<Object>();
		for (Object object : values) {
			flatten(flattened, object);
		}
		return flattened.toArray(new Object[flattened.size()]);
	}

	private static void flatten(List<Object> flattened, Object value) {
		if (value instanceof Object[]) {
			Object[] child = (Object[]) value;
			for (Object object : child) {
				flatten(flattened, object);
			}
		} else {
			flattened.add(value);
		}
	}

	@ClassRule
	public static TestRule stageCredentialsRule = new ExternalResource() {
		private UIServices originalService;

		private UIServices credentialsService;

		@Override
		protected void before() throws Throwable {
			IProvisioningAgent agent = (IProvisioningAgent) ServiceHelper.getService(Activator.getContext(),
					IProvisioningAgent.SERVICE_NAME);
			UIServices adminUIService = (UIServices) agent.getService(UIServices.SERVICE_NAME);
			originalService = adminUIService;
			credentialsService = new UIServices() {
				@Override
				public AuthenticationInfo getUsernamePassword(String location, AuthenticationInfo previousInfo) {
					if (previousInfo == null) {
						return getUsernamePassword(location);
					}
					return null;
				}

				@Override
				public AuthenticationInfo getUsernamePassword(String location) {
					if (location != null && location.contains("marketplace-staging")) {
						return new AuthenticationInfo("testuser", "plaintext", false);
					}
					throw new AssertionError("Unexpectedly required authentication for host " + location);
				}

				@Override
				public TrustInfo getTrustInfo(Certificate[][] untrustedChain, String[] unsignedDetail) {
					throw new AssertionError("Unexpectedly required trustinfo");
				}
			};
			agent.registerService(UIServices.SERVICE_NAME, credentialsService);
		}

		@Override
		protected void after() {
			UIServices originalService = this.originalService;
			UIServices credentialsService = this.credentialsService;
			this.originalService = null;
			this.credentialsService = null;
			IProvisioningAgent agent = (IProvisioningAgent) ServiceHelper.getService(Activator.getContext(),
					IProvisioningAgent.SERVICE_NAME);
			Object currentUIService = agent.getService(UIServices.SERVICE_NAME);
			if (currentUIService == credentialsService && originalService != null) {
				agent.registerService(UIServices.SERVICE_NAME, originalService);
			}
		}
	};

	@Rule
	public final TestRule xmlDumpRule = new TestWatcher() {

		private ServiceRegistration<IMarketplaceUnmarshaller> unmarshallerRegistration;

		@Override
		protected void starting(final Description description) {
			final IMarketplaceUnmarshaller marketplaceUnmarshaller = org.eclipse.epp.mpc.core.service.ServiceHelper
					.getMarketplaceUnmarshaller();
			unmarshallerRegistration = MarketplaceClientCorePlugin.getDefault().getServiceHelper()
					.registerMarketplaceUnmarshaller(new IMarketplaceUnmarshaller() {

						public <T> T unmarshal(InputStream in, Class<T> type, IProgressMonitor monitor)
								throws UnmarshalException, IOException {
							byte[] input = capture(in);
							in = null;
							try {
								return marketplaceUnmarshaller
										.unmarshal(new ByteArrayInputStream(input), type, monitor);
							} catch (UnmarshalException ex) {
								dump(description, ex, input);
								throw ex;
							} catch (IOException ex) {
								dump(description, ex, input);
								throw ex;
							} catch (RuntimeException ex) {
								dump(description, ex, input);
								throw ex;
							}
						}

						private byte[] capture(InputStream in) throws IOException {
							try {
								ByteArrayOutputStream dump = new ByteArrayOutputStream(32768);
								byte[] buffer = new byte[8192];
								for (int read = -1; (read = in.read(buffer)) != -1;) {
									dump.write(buffer, 0, read);
								}
								byte[] input = dump.toByteArray();
								return input;
							} finally {
								in.close();
							}
						}
					});
		}

		@Override
		protected void finished(Description description) {
			if (unmarshallerRegistration != null) {
				unmarshallerRegistration.unregister();
			}
		}

		void dump(Description description, Throwable ex, byte[] input) {
			String fileName = description.getDisplayName() + "_"
					+ new SimpleDateFormat("yyyyMMdd-HHmmss").format(new Date());
			fileName = safeFileName(fileName);
			File outputDir = findOutputDir();
			File dumpFile = new File(outputDir, fileName + "-response.dump");
			for (int i = 1; dumpFile.exists(); i++) {
				dumpFile = new File(outputDir, fileName + "_" + i + "-response.dump");
			}
			failed(new AssertionError("Dumping XML stream to " + dumpFile.getAbsolutePath()), description);
			FileOutputStream os = null;
			try {
				os = new FileOutputStream(dumpFile);
				os.write(input);
			} catch (Exception e) {
				failed(e, description);
			} finally {
				if (os != null) {
					try {
						os.close();
					} catch (IOException e) {
						failed(e, description);
					}
				}
			}
		}

		private File findOutputDir() {
			File targetDir = new File("target");
			if (targetDir.isDirectory()) {
				File sureFireDir = new File(targetDir, "surefire-reports");
				if (sureFireDir.isDirectory()) {
					return sureFireDir.getAbsoluteFile();
				}
				return targetDir.getAbsoluteFile();
			}
			URL resource = SolutionCompatibilityFilterTest.class.getResource("SolutionCompatibilityFilterTest.class");
			if (resource != null) {
				try {
					resource = FileLocator.resolve(resource);
					if ("file".equalsIgnoreCase(resource.getProtocol())) {
						for (File file = new File(resource.toURI()); file != null && file.exists(); file = file
								.getParentFile()) {
							targetDir = new File(file, "target");
							if (targetDir.isDirectory()) {
								File sureFireDir = new File(targetDir, "surefire-reports");
								if (sureFireDir.isDirectory()) {
									return sureFireDir.getAbsoluteFile();
								}
								return targetDir.getAbsoluteFile();
							}
						}
					}
				} catch (Exception e) {
				}
			}
			return new File(java.lang.System.getProperty("user.dir"));
		}

		private String safeFileName(String text) {
			char[] fileName = text.toCharArray();
			for (int i = 0; i < fileName.length; i++) {
				char c = fileName[i];
				if (!((c >= 48 && c <= 57 /* [0-9] */) || (c >= 65 && c <= 90 /* [A-Z] */)
						|| (c >= 97 && c <= 122 /* [a-z] */) || c == 45 /* - */|| c == 46 /* . */|| c == 95 /* _ */)) {
					fileName[i] = '_';
				}
			}
			return new String(fileName);
		}
	};

	@Rule
	public TestRule logRule = new TestRule() {

		public Statement apply(final Statement base, final Description description) {
			return LoggingSuite.isLogging() ? base : new Statement() {
				@Override
				public void evaluate() throws Throwable {
					try {
						log("Starting test " + description.getDisplayName());
						base.evaluate();
					} finally {
						log("Finished test " + description.getDisplayName());
					}
				}

				private void log(String message) {
					MarketplaceClientCore.error(message, null);
					java.lang.System.out.println(message);
				}
			};
		}
	};

	@Rule
	public TestRule requestInfoRule = new TestRule() {
		public Statement apply(final Statement base, final Description description) {
			String methodName = description.getMethodName();
			if (methodName.contains("SearchResult")) {
				return new Statement() {
					@Override
					public void evaluate() throws Throwable {
						try {
							base.evaluate();
						} catch (AssertionError t) {
							failedSearchQuery(t, description);
						}
					}
				};
			} else {
				return new Statement() {
					@Override
					public void evaluate() throws Throwable {
						try {
							base.evaluate();
						} catch (AssertionError t) {
							failedNodeQuery(t, description);
						}
					}
				};
			}
		}

		protected void failedSearchQuery(AssertionError error, Description description) {
			String request = marketplaceService.addMetaParameters(BASE_URL + "/"
					+ DefaultMarketplaceService.API_SEARCH_URI_FULL + solution.query());
			String queryDetail = "Unexpected result in search for node " + solution.shortName() + "\n   " + request;
			failedWithDetails(error, queryDetail);
		}

		protected void failedNodeQuery(AssertionError error, Description description) {
			String queryDetail = "Unexpected result in query for node " + solution.shortName() + "\n   "
					+ marketplaceService.addMetaParameters(solution.url() + "/api/p");
			failedWithDetails(error, queryDetail);
		}

		protected void failedWithDetails(AssertionError error, String queryDetail) throws AssertionError {
			String message = error.getMessage() == null ? queryDetail : queryDetail + "\n\n" + error.getMessage();

			String testDescription = SolutionCompatibilityFilterTest.this.testDescription;
			if (testDescription != null) {
				message = testDescription + "\n\n" + message;
			}
			throw adaptAssertionError(error, message);
		}

		protected AssertionError adaptAssertionError(AssertionError error, String message) {
			if (message == null || message.equals(error.getMessage())) {
				return error;
			}

			AssertionError newError;
			if (error.getClass() == AssertionError.class) {
				newError = new AssertionError(message);
			} else if (error.getClass() == ComparisonFailure.class) {
				ComparisonFailure comparisonFailure = (ComparisonFailure) error;
				newError = new ComparisonFailure(message, comparisonFailure.getExpected(), comparisonFailure
						.getActual());
			} else {
				newError = new AssertionError(message);
				newError.initCause(error);
			}
			newError.setStackTrace(error.getStackTrace());
			return newError;
		}
	};

	@Parameter(0)
	public Solution solution;

	@Parameter(1)
	public EclipseRelease eclipseRelease;

	@Parameter(2)
	public System system;

	@Parameter(3)
	public String version;

	@Parameter(4)
	public String site;

	@Parameter(5)
	public String[] features;

	@Parameter(6)
	public boolean compatible;

	@Parameter(7)
	public String testDescription;

	private DefaultMarketplaceService marketplaceService;

	@Before
	public void setupMarketplaceService() throws Exception {
		marketplaceService = new DefaultMarketplaceService(new URL(BASE_URL));
		marketplaceService.setRequestMetaParameters(computeRequestMetaParameters(system, eclipseRelease));
	}

	protected Map<String, String> computeRequestMetaParameters(System system, EclipseRelease eclipseRelease) {
		Map<String, String> requestMetaParameters = ServiceLocator.computeDefaultRequestMetaParameters();
		system.applyTo(requestMetaParameters);
		eclipseRelease.applyTo(requestMetaParameters);
		return requestMetaParameters;
	}

	protected INode queryNode() throws CoreException {
		INode node = marketplaceService.getNode(QueryHelper.nodeByUrl(solution.url()), new NullProgressMonitor());
		assertNotNull("Node {0} not found", node);
		if (solution.id() != null) {
			assertEquals("Node {2} returned with wrong id {1}", solution.id(), node.getId(), solution);
		}
		if (solution.url() != null) {
			assertEquals("Node {2} returned with wrong url {1}", solution.url(), node.getUrl(), solution);
		}
		return node;
	}

	protected INode searchForNode() throws CoreException {
		ISearchResult searchResult = marketplaceService.search(null, null, solution.query(), new NullProgressMonitor());
		assertSearchResultSanity(searchResult);
		List<? extends INode> nodes = searchResult.getNodes();
		INode foundNode = null;
		for (INode node : nodes) {
			if ((solution.id() != null && solution.id().equals(node.getId()))
					|| (solution.url() != null && solution.url().equals(node.getUrl()))) {
				foundNode = node;
				break;
			}
		}
		return foundNode;
	}

	protected void assertSearchResultSanity(ISearchResult result) {
		assertNotNull("Search result is null", result);
		assertNotNull("Result node list is null (internal error)", result.getNodes());
		assertNotNull("Result match count is null ('count' attribute missing)", result.getMatchCount());
		assertTrue("Total search result count {1} has to be at least the number of returned nodes {2}", result
				.getMatchCount() >= result.getNodes().size(), result.getMatchCount(), result.getNodes().size());

		Set<String> ids = new HashSet<String>();
		for (INode node : result.getNodes()) {
			assertNotNull("Search result node {1} without id", node.getId(), node);
			assertTrue("Duplicate search result node {1}", ids.add(node.getId()), node);
		}
	}

	@Test
	public void testNodeQuery() throws CoreException {
		if (compatible) {
			if (solution.installable()) {
				testCompatibleInstallableNode();
			} else {
				testCompatibleNonInstallableNode();
			}
		} else {
			testIncompatibleNode();
		}
	}

	public void testCompatibleInstallableNode() throws CoreException {
		assumeTrue("Skipping test - this solution and Eclipse/OS are incompatible", compatible);
		assumeTrue("Skipping test - this solution is not installable", solution.installable());
		INode node = queryNode();
		String updateurl = node.getUpdateurl();
		assertThat("Node {1} has no update url", updateurl, not(isEmptyOrNullString()), node);
		IIus ius = node.getIus();
		assertNotNull("Node {1} is missing <ius> element", ius, node);
		List<IIu> iuElements = ius.getIuElements();
		assertNotNull(iuElements);
		assertThat("Node {1} has no IUs", iuElements, not(empty()), node);

		if (version != null) {
			assertEquals("Node {2} has wrong version", version, node.getVersion(), node);
		}
		if (site != null) {
			assertEquals("Node {2} has wrong update site", site, node.getUpdateurl(), node);
		}
		if (features != null) {
			Set<String> allIUs = new HashSet<String>();
			for (IIu iu : iuElements) {
				allIUs.add(iu.getId());
			}
			assertThat("Node {1} is missing some features", allIUs, hasItems(features), node);
			assertThat("Node {1} has some unexpected features", allIUs, hasSize(features.length), node);
		}
	}

	public void testCompatibleNonInstallableNode() throws CoreException {
		assumeTrue("Skipping test - this solution and Eclipse/OS are incompatible", compatible);
		assumeFalse("Skipping test - this solution is installable", solution.installable());
		INode node = queryNode();
		String updateurl = node.getUpdateurl();
		assertNull("Uninstallable node {1} should not have an update url, but has {0}", updateurl, node);
		IIus ius = node.getIus();
		assertNull("Uninstallable node {1} should not have an <ius> element", ius, node);
	}

	public void testIncompatibleNode() throws CoreException {
		assumeFalse("Skipping test - this solution and Eclipse/OS are compatible", compatible);
		INode node = queryNode();
		String updateurl = node.getUpdateurl();
		assertNull("Incompatible node {1} should not have an update url, but has {0}", updateurl, node);
		IIus ius = node.getIus();
		assertNull("Incompatible node {1} should not have an <ius> element", ius, node);
	}

	@Test
	public void testSearchResult() throws CoreException {
		if (compatible) {
			testCompatibleSearchResult();
		} else {
			testIncompatibleSearchResult();
		}
	}

	public void testCompatibleSearchResult() throws CoreException {
		assumeTrue("Skipping test - this solution and Eclipse/OS are incompatible", compatible);
		INode foundNode = searchForNode();
		assertNotNull("Compatible node {1} not found in search", foundNode, solution);
	}

	public void testIncompatibleSearchResult() throws CoreException {
		assumeFalse("Skipping test - this solution and Eclipse/OS are compatible", compatible);
		INode foundNode = searchForNode();
		assertNull("Incompatible node {0} found in search", foundNode);
	}
}