org.eclipse.ant.core,

 org.eclipse.equinox.internal.provisional.p2.repository,

 org.eclipse.equinox.p2.internal.repository.tools,

		suite.addTestSuite(NewMirrorApplicationArtifactTest.class);

		suite.addTestSuite(NewMirrorApplicationMetadataTest.class);

import java.lang.reflect.Field;

	private int childCount = 0;

	/*

	 * Verify behaviour of contains(IArtifactDescriptor) when a child is marked bad

	 */

	public void testContainsDescriptorBadChild() {

		CompositeArtifactRepository source = null;

		IArtifactRepository childOne = null;

		IArtifactRepository childTwo = null;

		try {

			IArtifactDescriptor desc = new ArtifactDescriptor(new ArtifactKey("osgi", "a", new Version("1.0.0")));

			source = new CompositeArtifactRepository(new URI("memory:/in/memory"), "in memory test", null);

			childOne = createChild();

			source.addChild(childOne.getLocation());

			// Should always contain

			assertTrue("TestSetup failed", source.contains(desc));

			markBad(source, childOne);

			// Should not contain the descriptor of a bad child

			assertFalse("Composite repo contains descriptor despite child marked bad", source.contains(desc));

			// Add a child containing the descriptor

			childTwo = createChild();

			source.addChild(childTwo.getLocation());

			// Should contain the descriptor as the 'good' child has it.

			assertTrue("Composite repo should contain the descriptor", source.contains(desc));

		} catch (Exception e) {

			fail(e.getMessage(), e);

		} finally {

			if (source != null)

				getArtifactRepositoryManager().removeRepository(source.getLocation());

			if (childOne != null)

				getArtifactRepositoryManager().removeRepository(childOne.getLocation());

			if (childTwo != null)

				getArtifactRepositoryManager().removeRepository(childTwo.getLocation());

		}

	}

	/*

	 * Verify behaviour of contains(IArtifactKey) when a child is marked bad

	 */

	public void testContainsKeyBadChild() {

		CompositeArtifactRepository source = null;

		IArtifactRepository childOne = null;

		IArtifactRepository childTwo = null;

		try {

			IArtifactKey desc = new ArtifactKey("osgi", "a", new Version("1.0.0"));

			source = new CompositeArtifactRepository(new URI("memory:/in/memory"), "in memory test", null);

			childOne = createChild();

			source.addChild(childOne.getLocation());

			// Should always contain

			assertTrue("TestSetup failed", source.contains(desc));

			markBad(source, childOne);

			// Should not contain the descriptor of a bad child

			assertFalse("Composite repo contains descriptor despite child marked bad", source.contains(desc));

			// Add a child containing the descriptor

			childTwo = createChild();

			source.addChild(childTwo.getLocation());

			// Should contain the descriptor as the 'good' child has it.

			assertTrue("Composite repo should contain the descriptor", source.contains(desc));

		} catch (Exception e) {

			fail(e.getMessage(), e);

		} finally {

			if (source != null)

				getArtifactRepositoryManager().removeRepository(source.getLocation());

			if (childOne != null)

				getArtifactRepositoryManager().removeRepository(childOne.getLocation());

			if (childTwo != null)

				getArtifactRepositoryManager().removeRepository(childTwo.getLocation());

		}

	}

	/*

	 * Verify the behaviour of getAritfactKeys() when a child is marked bad

	 */

	public void testGetArtifactKeysBadChild() {

		CompositeArtifactRepository source = null;

		IArtifactRepository childOne = null;

		IArtifactRepository childTwo = null;

		try {

			source = new CompositeArtifactRepository(new URI("memory:/in/memory"), "in memory test", null);

			IArtifactKey key = new ArtifactKey("classifier", "name", new Version("1.0.0"));

			childOne = createChild();

			((TestArtifactRepository) childOne).addArtifact(key, new byte[] {});

			source.addChild(childOne.getLocation());

			assertTrue("Composite repo does not contain key", Arrays.asList(source.getArtifactKeys()).contains(key));

			markBad(source, childOne);

			assertFalse("Composite repo contains key but child is marked bad", Arrays.asList(source.getArtifactKeys()).contains(key));

			childTwo = createChild();

			((TestArtifactRepository) childTwo).addArtifact(key, new byte[] {});

			source.addChild(childTwo.getLocation());

			assertTrue("Composite repo does not contain key, but it is available", Arrays.asList(source.getArtifactKeys()).contains(key));

		} catch (Exception e) {

			fail(e.getMessage(), e);

		} finally {

			if (source != null)

				getArtifactRepositoryManager().removeRepository(source.getLocation());

			if (childOne != null)

				getArtifactRepositoryManager().removeRepository(childOne.getLocation());

			if (childTwo != null)

				getArtifactRepositoryManager().removeRepository(childTwo.getLocation());

		}

	}

	/*

	 * Verify the behaviour of getArtifactDescriptors(IArtifactKey) when a child is marked bad

	 */

	public void testGetArtifactDescriptorsBadChild() {

		CompositeArtifactRepository source = null;

		IArtifactRepository childOne = null;

		IArtifactRepository childTwo = null;

		try {

			source = new CompositeArtifactRepository(new URI("memory:/in/memory"), "in memory test", null);

			IArtifactKey key = new ArtifactKey("classifier", "name", new Version("1.0.0"));

			IArtifactDescriptor desc = new ArtifactDescriptor(key);

			childOne = createChild();

			childOne.addDescriptor(desc);

			((TestArtifactRepository) childOne).addArtifact(key, new byte[] {});

			source.addChild(childOne.getLocation());

			assertTrue("Composite repo does not contain descriptor", Arrays.asList(source.getArtifactDescriptors(key)).contains(desc));

			markBad(source, childOne);

			assertFalse("Composite repo contains descriptor but child is marked bad", Arrays.asList(source.getArtifactDescriptors(key)).contains(desc));

			childTwo = createChild();

			childOne.addDescriptor(desc);

			((TestArtifactRepository) childTwo).addArtifact(key, new byte[] {});

			source.addChild(childTwo.getLocation());

			assertTrue("Composite repo does not contain descriptor, but it is available", Arrays.asList(source.getArtifactDescriptors(key)).contains(desc));

		} catch (Exception e) {

			fail(e.getMessage(), e);

		} finally {

			if (source != null)

				getArtifactRepositoryManager().removeRepository(source.getLocation());

			if (childOne != null)

				getArtifactRepositoryManager().removeRepository(childOne.getLocation());

			if (childTwo != null)

				getArtifactRepositoryManager().removeRepository(childTwo.getLocation());

		}

	}

	/*

	 * Mark a child of a Composite repository as bad

	 */

	protected void markBad(CompositeArtifactRepository parent, IArtifactRepository child) {

		try {

			Field field = CompositeArtifactRepository.class.getDeclaredField("loadedRepos");

			field.setAccessible(true);

			Class[] classes = CompositeArtifactRepository.class.getDeclaredClasses();

			Class childInfo = null;

			for (int i = 0; i < classes.length && childInfo == null; i++) {

				if (classes[i].getName().equals("org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository$ChildInfo"))

					childInfo = classes[i];

			}

			assertTrue("Unable to locate inner class ChildInfo", childInfo != null);

			Field repo = childInfo.getDeclaredField("repo");

			repo.setAccessible(true);

			Field good = childInfo.getDeclaredField("good");

			good.setAccessible(true);

			List list = (List) field.get(parent);

			for (Iterator listIter = list.iterator(); listIter.hasNext();) {

				Object obj = listIter.next();

				if (child.equals(repo.get(obj))) {

					good.set(obj, false);

					return;

				}

			}

			fail("Unable to mark as bad:" + child);

		} catch (Exception e) {

			fail("Test setup failed:" + e.getMessage(), e);

		}

	}

	/*

	 * Create a child for a composite repository which always responds true to contains()

	 */

	protected IArtifactRepository createChild() {

		try {

			TestArtifactRepository repo = new TestArtifactRepository(new URI("memory:/in/memory/" + childCount++)) {

				public boolean contains(IArtifactDescriptor desc) {

					return true;

				}

				public boolean contains(IArtifactKey desc) {

					return true;

				}

			};

			repo.addToRepositoryManager();

			return repo;

		} catch (URISyntaxException e) {

			fail("Failed creating child repo", e);

			return null;

		}

	}

package org.eclipse.equinox.p2.tests;

import java.io.File;

import java.io.FileOutputStream;

import java.net.URI;

import java.util.*;

import org.eclipse.ant.core.AntRunner;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.URIUtil;

import org.eclipse.equinox.internal.p2.persistence.XMLWriter;

public class AbstractAntProvisioningTest extends AbstractProvisioningTest {

	protected static final String TYPE_ARTIFACT = "A";

	protected static final String TYPE_METADATA = "M";

	private static final String TARGET = "target";

	private static final String ROOT = "project";

	private static final String NAME = "name";

	private static final String DEFAULT_TARGET = "default";

	private static final String DEFAULT_NAME = "default";

	AntTaskElement root, target;

	File buildScript, logLocation;

	public void setUp() throws Exception {

		super.setUp();

		buildScript = new File(getTempFolder(), getUniqueString());

		logLocation = new File(getTempFolder(), getUniqueString());

		createBuildScript();

	}

	public void tearDown() throws Exception {

		// Delete the build script

		delete(buildScript.getParentFile());

		delete(logLocation.getParentFile());

		super.tearDown();

	}

	/*

	 * Run the specified buildscript

	 */

	protected void runAntTask(File buildFile) {

		try {

			runAntTaskWithExceptions(buildFile);

		} catch (CoreException e) {

			fail(rootCause(e));

		}

	}

	private void runAntTaskWithExceptions(File buildFile) throws CoreException {

		AntRunner ant = new AntRunner();

		ant.setArguments("-logfile \"" + logLocation + "\"");

		ant.setBuildFileLocation(buildFile.getAbsolutePath());

		ant.addBuildLogger("org.apache.tools.ant.XmlLogger");

		ant.run();

	}

	/*

	 * Run the build script described programmatically

	 */

	protected void runAntTask() {

		try {

			runAntTaskWithExceptions();

		} catch (CoreException e) {

			fail(rootCause(e));

		}

	}

	protected void runAntTaskWithExceptions() throws CoreException {

		try {

			writeBuildScript();

		} catch (Exception e) {

			fail("Error writing build script", e);

		}

		runAntTaskWithExceptions(buildScript);

	}

	/*

	 * Adds an Ant Task to the build script

	 */

	protected void addTask(AntTaskElement task) {

		target.addElement(task);

	}

	/*

	 * Create and return an repository element for this address and type

	 */

	protected AntTaskElement getRepositoryElement(URI address, String kind) {

		return getRepositoryElement(address, kind, null, null, null, null);

	}

	protected AntTaskElement getRepositoryElement(URI address, String kind, String name, String format, Boolean compressed, Boolean append) {

		AntTaskElement repo = new AntTaskElement("repository");

		repo.addAttributes(new String[] {"location", URIUtil.toUnencodedString(address)});

		if (kind != null)

			repo.addAttributes(new String[] {"kind", kind});

		if (name != null)

			repo.addAttributes(new String[] {"name", name});

		if (format != null)

			repo.addAttributes(new String[] {"format", format});

		if (compressed != null)

			repo.addAttributes(new String[] {"compressed", compressed.toString()});

		if (append != null)

			repo.addAttributes(new String[] {"append", append.toString()});

		return repo;

	}

	/*

	 * Create the base elements of the build script

	 */

	private void createBuildScript() {

		root = new AntTaskElement(ROOT);

		root.addAttributes(new String[] {NAME, ROOT, DEFAULT_TARGET, DEFAULT_NAME});

		target = new AntTaskElement(TARGET);

		target.addAttributes(new String[] {NAME, DEFAULT_NAME});

		root.addElement(target);

	}

	/*

	 * Write the build script to disk

	 */

	private void writeBuildScript() throws Exception {

		FileOutputStream outputStream = null;

		try {

			outputStream = new FileOutputStream(buildScript);

			XMLWriter writer = new XMLWriter(outputStream, null);

			writeElement(writer, root);

			writer.flush();

		} finally {

			if (outputStream != null)

				outputStream.close();

		}

	}

	/*

	 * Write an element to the buildscript

	 */

	private void writeElement(XMLWriter writer, AntTaskElement task) {

		// Properties ought to occur in key-value pairs 

		assertTrue("Task " + task + " should have an even number of properties", (task.attributes.size() % 2) == 0);

		// Start tag

		writer.start(task.name);

		// write properties

		for (Iterator iter = task.attributes.iterator(); iter.hasNext();)

			writer.attribute((String) iter.next(), (String) iter.next());

		// write sub elements if applicable

		for (Iterator iter = task.elements.iterator(); iter.hasNext();)

			writeElement(writer, (AntTaskElement) iter.next());

		// close tag

		writer.end();

	}

	// Class which can be used to represent elements in a task

	protected class AntTaskElement {

		public String name;

		public List attributes = new ArrayList();

		public List elements = new ArrayList();

		public AntTaskElement(String name) {

			this.name = name;

		}

		public void addAttribute(String attribute, String value) {

			attributes.add(attribute);

			attributes.add(value);

		}

		public void addAttributes(String[] propertyArray) {

			attributes.addAll(Arrays.asList(propertyArray));

		}

		public void addElement(AntTaskElement element) {

			elements.add(element);

		}

		public String toString() {

			return name;

		}

	}

	protected static Throwable rootCause(Throwable e) {

		if (e.getCause() != null)

			return rootCause(e.getCause());

		return e;

	}

	protected static void fail(Throwable e) {

		fail("An exception occurred while running the task", e);

	}

	protected void assertLogContains(String content) {

		try {

			assertLogContainsLine(logLocation, content);

		} catch (Exception e) {

			fail("Error asserting log contents.", e);

		}

	}

}

package org.eclipse.equinox.p2.tests.ant;

import java.io.File;

import java.net.URI;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.URIUtil;

import org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository;

import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository;

import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepository;

import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;

import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;

import org.eclipse.equinox.p2.tests.AbstractAntProvisioningTest;

public class CreateCompositeRepositoryTaskTest extends AbstractAntProvisioningTest {

	private URI compositeSite;

	private static URI HTTP_SITE;

	public void setUp() throws Exception {

		super.setUp();

		// Get a random location to create a repository

		compositeSite = (new File(getTempFolder(), getUniqueString())).toURI();

		HTTP_SITE = new URI("http://download.eclipse.org/eclipse/updates/3.4/");

	}

	public void tearDown() throws Exception {

		// Remove repository manager references

		getArtifactRepositoryManager().removeRepository(compositeSite);

		getMetadataRepositoryManager().removeRepository(compositeSite);

		// Cleanup disk

		delete(new File(compositeSite));

		super.tearDown();

	}

	public void testCreateCompositeArtifactRepository() throws Exception {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_ARTIFACT);

		addTask(createCompositeTask);

		runAntTask();

		assertTrue(getArtifactRepositoryManager().contains(compositeSite));

		assertTrue(getArtifactRepositoryManager().loadRepository(compositeSite, null) instanceof CompositeArtifactRepository);

	}

	public void testCreateCompositeMetadataRepository() throws Exception {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_METADATA);

		addTask(createCompositeTask);

		runAntTask();

		assertTrue(getMetadataRepositoryManager().contains(compositeSite));

		assertTrue(getMetadataRepositoryManager().loadRepository(compositeSite, null) instanceof CompositeMetadataRepository);

	}

	public void testCreateCombinedCompositeRepository() throws Exception {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(null);

		addTask(createCompositeTask);

		runAntTask();

		assertTrue(getMetadataRepositoryManager().contains(compositeSite));

		assertTrue(getArtifactRepositoryManager().contains(compositeSite));

		assertTrue(getMetadataRepositoryManager().loadRepository(compositeSite, null) instanceof CompositeMetadataRepository);

		assertTrue(getArtifactRepositoryManager().loadRepository(compositeSite, null) instanceof CompositeArtifactRepository);

	}

	public void testFailOnExists() throws Exception {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_ARTIFACT);

		addTask(createCompositeTask);

		runAntTask();

		// Set failOnExists

		createCompositeTask.addAttributes(new String[] {"failOnExists", String.valueOf(true)});

		Throwable exception = null;

		try {

			runAntTaskWithExceptions();

		} catch (CoreException e) {

			exception = rootCause(e);

		}

		if (!exception.getMessage().contains("exists"))

			fail("Unexpected exception: ", exception);

	}

	public void testNotCompressed() throws Exception {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_ARTIFACT);

		addTask(createCompositeTask);

		// Set the compressed attribute to false

		((AntTaskElement) createCompositeTask.elements.get(0)).addAttributes(new String[] {"compressed", String.valueOf(false)});

		runAntTask();

		try {

			IArtifactRepository repo = getArtifactRepositoryManager().loadRepository(compositeSite, null);

			assertTrue(repo instanceof CompositeArtifactRepository);

			assertFalse("The repository is compressed", Boolean.valueOf((String) repo.getProperties().get(IRepository.PROP_COMPRESSED)));

		} catch (ProvisionException e) {

			fail("Failed to load repository", e);

		}

	}

	public void testName() {

		String repoName = "My Test Repository";

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_ARTIFACT);

		addTask(createCompositeTask);

		// Set the repository name

		((AntTaskElement) createCompositeTask.elements.get(0)).addAttributes(new String[] {"name", repoName});

		runAntTask();

		try {

			IArtifactRepository repo = getArtifactRepositoryManager().loadRepository(compositeSite, null);

			assertTrue(repo instanceof CompositeArtifactRepository);

			assertEquals(repoName, repo.getName());

		} catch (ProvisionException e) {

			fail("Failed to load repository", e);

		}

	}

	public void testAddChild() {

		// Create Composite Repository Task

		AntTaskElement createCompositeTask = getCreateCompositeTask(TYPE_ARTIFACT);

		addTask(createCompositeTask);

		// Create add element

		AntTaskElement addElement = new AntTaskElement("add");

		// Add a repository

		addElement.addElement(getRepositoryElement(HTTP_SITE, TYPE_ARTIFACT));

		createCompositeTask.addElement(addElement);

		runAntTask();

		try {

			CompositeArtifactRepository repo = (CompositeArtifactRepository) getArtifactRepositoryManager().loadRepository(compositeSite, null);

			assertTrue(repo.getChildren().contains(HTTP_SITE));

		} catch (ProvisionException e) {

			fail("Failed to load repository", e);

		}

	}

	public void testInvalidLocation() throws Exception {

		URI location = URIUtil.fromString("scheme:/location");

		AntTaskElement createCompositeTask = new AntTaskElement("p2.create.composite.repository");

		createCompositeTask.addElement(getRepositoryElement(location, TYPE_ARTIFACT));

		addTask(createCompositeTask);

		Exception exception = null;

		try {

			runAntTaskWithExceptions();

		} catch (CoreException e) {

			exception = e;

			if (!(rootCause(e) instanceof IllegalStateException))

				fail("Expected IllegalStateException.", e);

			else {

				try {

					getArtifactRepositoryManager().loadRepository(location, null);

					fail("Repository with invalid location loaded.");

				} catch (ProvisionException e2) {

					// This is a success

				}

			}

		}

		if (exception == null)

			fail("No exception thrown");

	}

	private AntTaskElement getCreateCompositeTask(String type) {

		AntTaskElement createCompositeTask = new AntTaskElement("p2.create.composite.repository");

		createCompositeTask.addElement(getRepositoryElement(compositeSite, type));

		return createCompositeTask;

	}

}

/*******************************************************************************

 *  Copyright (c) 2008, 2009 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.p2.tests.mirror;

import java.io.*;

import java.lang.reflect.Field;

import java.net.MalformedURLException;

import java.net.URI;

import java.util.*;

import org.eclipse.core.runtime.*;

import org.eclipse.equinox.internal.p2.artifact.processors.md5.Messages;

import org.eclipse.equinox.internal.p2.artifact.repository.*;

import org.eclipse.equinox.internal.p2.artifact.repository.Activator;

import org.eclipse.equinox.internal.p2.artifact.repository.simple.SimpleArtifactRepository;

import org.eclipse.equinox.internal.p2.core.helpers.OrderedProperties;

import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper;

import org.eclipse.equinox.internal.provisional.p2.artifact.repository.*;

import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;

import org.eclipse.equinox.internal.provisional.p2.core.Version;

import org.eclipse.equinox.internal.provisional.p2.metadata.IArtifactKey;

import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;

import org.eclipse.equinox.p2.internal.repository.tools.*;

import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;

import org.eclipse.equinox.p2.tests.TestActivator;

import org.eclipse.equinox.spi.p2.publisher.PublisherHelper;

import org.eclipse.osgi.framework.log.FrameworkLog;

import org.eclipse.osgi.util.NLS;

/**

 * Test API of the basic mirror application functionality's implementation.

 */

public class NewMirrorApplicationArtifactTest extends AbstractProvisioningTest {

	protected File destRepoLocation;

	protected File sourceRepoLocation; //helloworldfeature

	protected File sourceRepo2Location; //anotherfeature

	protected File sourceRepo3Location; //helloworldfeature + yetanotherfeature

	protected File sourceRepo4Location; //helloworldfeature v1.0.1

	/* (non-Javadoc)

	 * @see org.eclipse.equinox.p2.tests.AbstractProvisioningTest#setUp()

	 */

	protected void setUp() throws Exception {

		super.setUp();

		//load all the repositories

		sourceRepoLocation = getTestData("0.0", "/testData/mirror/mirrorSourceRepo1 with space");

		sourceRepo2Location = getTestData("0.1", "/testData/mirror/mirrorSourceRepo2");

		sourceRepo3Location = getTestData("0.2", "/testData/mirror/mirrorSourceRepo3");

		sourceRepo4Location = getTestData("0.3", "/testData/mirror/mirrorSourceRepo4");

		//create destination location

		destRepoLocation = new File(getTempFolder(), "BasicMirrorApplicationTest");

		delete(destRepoLocation);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.equinox.p2.tests.AbstractProvisioningTest#tearDown()

	 */

	protected void tearDown() throws Exception {

		//remove all the repositories

		getArtifactRepositoryManager().removeRepository(destRepoLocation.toURI());

		getArtifactRepositoryManager().removeRepository(sourceRepoLocation.toURI());

		getArtifactRepositoryManager().removeRepository(sourceRepo2Location.toURI());

		getArtifactRepositoryManager().removeRepository(sourceRepo3Location.toURI());

		getArtifactRepositoryManager().removeRepository(sourceRepo4Location.toURI());

		//delete the destination location (no left over files for the next test)

		delete(destRepoLocation);

		super.tearDown();

	}

	private void basicRunMirrorApplication(String message, URI source, URI destination, Boolean append, Boolean formatDestination, String destName) throws Exception {

		MirrorApplication app = new MirrorApplication();

		if (destination != null) {

			RepositoryDescriptor dest = null;

			if (formatDestination != null && formatDestination)

				dest = createRepositoryDescriptor(destination, append, source, destName);

			else

				dest = createRepositoryDescriptor(destination, append, null, destName);

			app.addDestination(dest);

		}

		if (source != null) {

			RepositoryDescriptor src = createRepositoryDescriptor(source, null, null, null);

			app.addSource(src);

		}

		app.run(null);

	}

	private void basicRunMirrorApplication(String message, URI source, URI destination, Boolean append, Boolean formatDestination) throws Exception {

		basicRunMirrorApplication(message, source, destination, append, formatDestination, null);

	}

	private void basicRunMirrorApplication(String message, URI source, URI destination) throws Exception {

		basicRunMirrorApplication(message, source, destination, null, null, null);

	}

	private RepositoryDescriptor createRepositoryDescriptor(URI location, Boolean append, URI format, String name) {

		RepositoryDescriptor descriptor = new RepositoryDescriptor();

		descriptor.setLocation(location);

		descriptor.setKind("artifact");

		if (append != null)

			descriptor.setAppend(append);

		if (format != null)

			descriptor.setFormat(format);

		if (name != null)

			descriptor.setName(name);

		return descriptor;

	}

	private CompositeArtifactRepository getCompositeSourceRepo(MirrorApplication app) {

		try {

			Field repo = AbstractApplication.class.getDeclaredField("compositeArtifactRepository");

			repo.setAccessible(true);

			return (CompositeArtifactRepository) repo.get(app);

		} catch (Exception e) {

			fail("Failed to obtain composite repo", e);

			return null;

		}

	}

	/**

	 * just a wrapper method for compatibility

	 */

	private void runMirrorApplication(String message, File source, File destination, boolean append) {

		try {

			basicRunMirrorApplication(message, source.toURI(), destination.toURI(), append, false);

		} catch (Exception e) {

			fail(message, e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to an empty repository

	 * Source contains A, B

	 * Target contains

	 */

	private void artifactMirrorToEmpty(String message, boolean append, boolean format) {

		try {

			//destination repo is created blank

			basicRunMirrorApplication(message, sourceRepoLocation.toURI(), destRepoLocation.toURI(), append, format);

		} catch (Exception e) {

			fail(message, e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with non-duplicate entries

	 * Source contains A, B

	 * Target contains C, D

	 */

	private void artifactMirrorToPopulated(String message, boolean append) {

		//Setup: populate destination with non-duplicate artifacts

		runMirrorApplication(message + ".0", sourceRepo2Location, destRepoLocation, false); //value of append should not matter

		try {

			//Setup ensure setup completes successfully

			assertContentEquals(message + ".1", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".2", e);

		}

		//mirror test data

		runMirrorApplication(message + ".4", sourceRepoLocation, destRepoLocation, append);

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with exact duplicate data

	 * Source contains A, B

	 * Target contains A, B

	 */

	private void artifactMirrorToFullDuplicate(String message, boolean append) {

		//Setup: populate destination with duplicate artifacts

		runMirrorApplication(message + ".0", sourceRepoLocation, destRepoLocation, false); //value of append should not matter

		try {

			//Setup: verify contents

			assertContentEquals(message + ".1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".2", e);

		}

		//mirror test data

		runMirrorApplication(message + ".4", sourceRepoLocation, destRepoLocation, append);

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with partially duplicate data

	 * Source contains A, B, C, D

	 * Target contains  A, B

	 */

	private void artifactMirrorToPartialDuplicate(String message, boolean append) {

		//Setup: populate destination with duplicate artifacts

		runMirrorApplication(message + ".0", sourceRepoLocation, destRepoLocation, false);

		try {

			//Setup: verify contents

			assertContentEquals(message + ".1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".2", e);

		}

		//mirror test data

		runMirrorApplication(message + ".4", sourceRepo3Location, destRepoLocation, append);

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both full duplicate and non-duplicate data

	 * Source contains A, B

	 * Target contains A, B, C, D

	 */

	private void artifactMirrorToPopulatedWithFullDuplicate(String message, boolean append) {

		//Setup: populate destination with non-duplicate artifacts

		runMirrorApplication(message + ".0", sourceRepo3Location, destRepoLocation, false); //value of append should not matter

		try {

			//Setup: verify

			assertContentEquals(message + ".1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".2", e);

		}

		//mirror duplicate data

		runMirrorApplication(message + ".4", sourceRepoLocation, destRepoLocation, append);

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both partial duplicate and non-duplicate data

	 * Source contains A, B, C, D

	 * Target contains A, B, E, F

	 */

	private void artifactMirrorToPopulatedWithPartialDuplicate(String message, boolean append) {

		//Setup: populate destination with non-duplicate artifacts

		runMirrorApplication(message + ".0", sourceRepo2Location, destRepoLocation, false); //value of append should not matter

		try {

			//Setup: verify

			assertContentEquals(message + ".1", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".2", e);

		}

		//Setup: populate destination with duplicate artifacts

		runMirrorApplication(message + ".4", sourceRepoLocation, destRepoLocation, true);

		try {

			//Setup: verify

			assertContains(message + ".5", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContains(message + ".6", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail(message + ".7", e);

		}

		//mirror duplicate data

		runMirrorApplication(message + ".9", sourceRepo3Location, destRepoLocation, append);

	}

	/**

	 * Tests mirroring all artifacts from an empty repository

	 * Source contains

	 */

	private File artifactMirrorEmpty(String message, boolean append) {

		//Setup: Create an empty repository

		File emptyRepository = new File(getTempFolder(), getUniqueString());

		//Setup: remove repository if it exists

		getArtifactRepositoryManager().removeRepository(emptyRepository.toURI());

		//Setup: delete any data that may be in the folder

		delete(emptyRepository);

		try {

			getArtifactRepositoryManager().createRepository(emptyRepository.toURI(), "Empty Repository", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		} catch (ProvisionException e) {

			fail(message + ".1", e);

		}

		runMirrorApplication(message + ".0", emptyRepository, destRepoLocation, append);

		return emptyRepository; //return the repository for use in verification

	}

	/**

	 * Tests mirroring all artifacts from an empty repository

	 * Source contains

	 */

	private File artifactMirrorEmptyToPopulated(String message, boolean append) {

		//Setup: Populate the repository

		runMirrorApplication(message + ".0", sourceRepoLocation, destRepoLocation, false);

		return artifactMirrorEmpty(message + ".1", append); //create the empty repository, perform the mirror, pass the result back

	}

	/**

	 * Runs mirror app on source with missing artifact with "-ignoreErrors"

	 */

	private void mirrorWithError(boolean verbose) {

		File errorSourceLocation = getTestData("loading error data", "testData/mirror/mirrorErrorSourceRepo");

		//repo contains an artifact entry for a file that does not exist on disk. this should throw a file not found exception

		try {

			MirrorApplication app = new MirrorApplication();

			app.addSource(createRepositoryDescriptor(errorSourceLocation.toURI(), null, null, null));

			app.addDestination(createRepositoryDescriptor(destRepoLocation.toURI(), null, null, null));

			//Set ignoreErrors flag. Set verbose flag if verbose == true

			app.setVerbose(verbose);

			app.setIgnoreErrors(true);

			//run the mirror application

			app.run(null);

		} catch (Exception e) {

			fail("Running mirror application with errored source failed", e);

		}

	}

	/**

	 * ensures that all files with entries in the repo have corresponding files on disk.

	 * Not Biconditional.

	 */

	private void assertFileSizes(String message, SimpleArtifactRepository expected, SimpleArtifactRepository actual) {

		IArtifactKey[] expectedKeys = expected.getArtifactKeys();

		for (int i = 0; i < expectedKeys.length; i++) {

			IArtifactDescriptor[] expectedDescriptors = expected.getArtifactDescriptors(expectedKeys[i]);

			IArtifactDescriptor[] actualDescriptors = actual.getArtifactDescriptors(expectedKeys[i]);

			if (expectedDescriptors == null || actualDescriptors == null)

				if (!(expectedDescriptors == null && actualDescriptors == null))

					fail(message + " missing key " + expectedKeys[i]);

			top: for (int j = 0; j < expectedDescriptors.length; j++) {

				for (int k = 0; k < actualDescriptors.length; k++) {

					if (Arrays.equals(expectedDescriptors[j].getProcessingSteps(), actualDescriptors[k].getProcessingSteps())) {

						File expectedFile = expected.getArtifactFile(expectedDescriptors[j]);

						File actualFile = actual.getArtifactFile(actualDescriptors[k]);

						if (expectedFile == null || actualFile == null)

							fail(message + " descriptor mismatch");

						if (!(expectedFile.exists() && actualFile.exists()))

							fail(message + " file does not exist");

						assertTrue(expectedFile.length() == actualFile.length());

						continue top;

					}

				}

				fail(message + "Missing expected descriptor" + expectedDescriptors[j]);

			}

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to an empty repository

	 * Source contains A, B

	 * Target contains

	 * Expected is A, B

	 */

	public void testArtifactMirrorToEmpty() {

		artifactMirrorToEmpty("1.0", true, false); // run the test with append set to true

		try {

			//verify destination's content

			assertContentEquals("1.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("1.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to an empty repository with "-writeMode clean"

	 * Source contains A, B

	 * Target contains

	 * Expected is A, B

	 */

	public void testArtifactMirrorToEmptyWithClean() {

		artifactMirrorToEmpty("2.0", false, false);

		try {

			//verify destination's content

			assertContentEquals("2.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("2.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with exact duplicate data

	 * Source contains A, B

	 * Target contains A, B

	 * Expected is A, B

	 */

	public void testArtifactMirrorToFullDuplicate() {

		artifactMirrorToFullDuplicate("3.0", true); //run the test with append set to true

		try {

			//verify destination's content

			assertContentEquals("3.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("3.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with exact duplicate data with "-writeMode clean"

	 * Source contains A, B

	 * Target contains A, B

	 * Expected is A, B

	 */

	public void testArtifactMirrorToFullDuplicateWithClean() {

		artifactMirrorToFullDuplicate("4.0", false);

		try {

			//verify destination's content

			assertContentEquals("4.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("4.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with non-duplicate entries

	 * Source contains A, B

	 * Target contains C, D

	 * Expected is A, B, C, D

	 */

	public void testArtifactMirrorToPopulated() {

		artifactMirrorToPopulated("5.0", true); //run the test with append set to true

		try {

			//verify destination's content

			assertContains("5.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContains("5.2", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//checks that the destination has the correct number of keys (no extras)

			assertEquals("5.3", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null).getArtifactKeys().length + getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null).getArtifactKeys().length, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getArtifactKeys().length);

		} catch (ProvisionException e) {

			fail("5.4", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with non-duplicate entries with "-writeMode clean"

	 * Source contains A, B

	 * Target contains C, D

	 * Expected is A, B

	 */

	public void testArtifactMirrorToPopulatedWithClean() {

		artifactMirrorToPopulated("6.0", false);

		try {

			//verify destination's content

			assertContentEquals("6.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("6.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with partially duplicate data

	 * Source contains A, B, C, D

	 * Target contains  A, B

	 * Expected is A, B, C, D

	 */

	public void testArtifactMirrorToPartialDuplicate() {

		artifactMirrorToPartialDuplicate("7.0", true); //run the test with append set to true

		try {

			//verify destination's content

			assertContentEquals("7.1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("7.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with partially duplicate data with "-writeMode clean"

	 * Source contains A, B, C, D

	 * Target contains  A, B

	 * Expected is A, B, C, D

	 */

	public void testArtifactMirrorToPartialDuplicateWithClean() {

		artifactMirrorToPartialDuplicate("8.0", false);

		try {

			//verify destination's content

			assertContentEquals("8.1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("8.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both full duplicate and non-duplicate data

	 * Source contains A, B

	 * Target contains A, B, C, D

	 * Expected is A, B, C, D

	 */

	public void testArtifactMirrorToPopulatedWithFullDuplicate() {

		artifactMirrorToPopulatedWithFullDuplicate("9.0", true); //run the test with append set to true

		try {

			//verify destination's content

			assertContentEquals("9.1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("9.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both full duplicate and non-duplicate data with "-writeMode clean"

	 * Source contains A, B

	 * Target contains A, B, C, D

	 * Expected is A, B

	 */

	public void testArtifactMirrorToPopulatedWithFullDuplicateWithClean() {

		artifactMirrorToPopulatedWithFullDuplicate("10.0", false);

		try {

			//verify destination's content

			assertContentEquals("10.1", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("10.2", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both partial duplicate and non-duplicate data

	 * Source contains A, B, C, D

	 * Target contains A, B, E, F

	 * Expected is A, B, C, D, E, F

	 */

	public void testArtifactMirrorToPopulatedWithPartialDuplicate() {

		artifactMirrorToPopulatedWithPartialDuplicate("11.0", true); //run the test with append set to true

		try {

			//verify destination's content

			assertContains("11.1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContains("11.2", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//checks that the destination has the correct number of keys (no extras)

			assertEquals("11.3", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null).getArtifactKeys().length + getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null).getArtifactKeys().length, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getArtifactKeys().length);

		} catch (ProvisionException e) {

			fail("11.4", e);

		}

	}

	/**

	 * Tests mirroring all artifacts in a repository to a repository populated with both partial duplicate and non-duplicate data with "-writeMode clean"

	 * Source contains A, B, C, D

	 * Target contains A, B, E, F

	 * Expected is A, B, C, D

	 */

	public void testArtifactMirrorToPopulatedWithPartialDuplicateWithClean() {

		artifactMirrorToPopulatedWithPartialDuplicate("12.0", false);

		try {

			//verify destination's content

			assertContentEquals("12.1", getArtifactRepositoryManager().loadRepository(sourceRepo3Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("12.2", e);

		}

	}

	/**

	 * Tests MirrorApplication's behaviour when given an invalid source repository

	 */

	public void testArtifactMirrorFromInvalid() {

		File invalidRepository = new File(getTempFolder(), getUniqueString());

		delete(invalidRepository);

		try {

			basicRunMirrorApplication("13.1", invalidRepository.toURI(), destRepoLocation.toURI(), true, false);

			//we expect a provision exception to be thrown. We should never get here.

			fail("13.0 ProvisionExpection not thrown");

		} catch (ProvisionException e) {

			return; //correct type of exception has been thrown

		} catch (Exception e) {

			fail("13.2", e);

		}

	}

	/**

	 * Tests MirrorApplication's behaviour when given an invalid destination repository

	 */

	public void testArtifactMirrorToInvalid() {

		try {

			//Setup: create a URI pointing to an unmodifiable place

			URI invalidDestRepository = new URI("http://foobar.com/abcdefg");

			//run the application with the modifiable destination

			basicRunMirrorApplication("14.1", sourceRepoLocation.toURI(), invalidDestRepository, true, false);

			//we're expecting an UnsupportedOperationException so we should never get here

			fail("14.0 UnsupportedOperationException not thrown");

		} catch (UnsupportedOperationException e) {

			return; //correct type of exception has been thrown

		} catch (Exception e) {

			fail("14.2", e);

		}

	}

	/**

	 * Tests MirrorApplication's behaviour when given both an invalid source and an invalid destination repository

	 */

	public void testArtifactMirrorBothInvalid() {

		//Setup: create a file that is not a valid repository

		File invalidRepository = new File(getTempFolder(), getUniqueString());

		//Setup: delete any leftover data

		delete(invalidRepository);

		try {

			//Setup: create a URI pointing to an unmodifiable place

			URI invalidDestRepository = new URI("http://foobar.com/abcdefg");

			basicRunMirrorApplication("15.1", invalidRepository.toURI(), invalidDestRepository, true, false);

			//We expect the ProvisionException to be thrown

			fail("15.0 ProvisionException not thrown");

		} catch (ProvisionException e) {

			return; //correct type of exception was thrown

		} catch (Exception e) {

			fail("15.2", e);

		}

	}

	/**

	 * Tests mirroring an empty repository to another empty repository

	 * Source contains

	 * Target contains

	 * Expected is

	 */

	public void testArtifactMirrorEmptyToEmpty() {

		File emptyRepository = artifactMirrorEmpty("16.0", true);

		try {

			//verify destination's content

			assertContentEquals("16.1", getArtifactRepositoryManager().loadRepository(emptyRepository.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("16.2", e);

		}

		//remove the emptyRepository

		getArtifactRepositoryManager().removeRepository(emptyRepository.toURI());

		//delete any left over data

		delete(emptyRepository);

	}

	/**

	 * Tests mirroring an empty repository to a populated repository

	 * Source contains

	 * Target contains A, B

	 * Expected is A, B

	 */

	public void testArtifactMirrorEmptyToPopulated() {

		File emptyRepository = artifactMirrorEmptyToPopulated("17.0", true);

		try {

			//verify destination's content

			assertContains("17.1", getArtifactRepositoryManager().loadRepository(emptyRepository.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContentEquals("17.2", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("17.3", e);

		}

		//remove the empty repository

		getArtifactRepositoryManager().removeRepository(emptyRepository.toURI());

		//remove any leftover data

		delete(emptyRepository);

	}

	/**

	 * Tests mirroring an empty repository to a populated repository with "-writeMode clean"

	 * Source contains

	 * Target contains A, B

	 * Expected is

	 */

	public void testArtifactMirrorEmptyToPopulatedWithClean() {

		File emptyRepository = artifactMirrorEmptyToPopulated("18.0", false);

		try {

			//verify destination's content

			assertContentEquals("18.1", getArtifactRepositoryManager().loadRepository(emptyRepository.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("18.2", e);

		}

		//remove the empty repository

		getArtifactRepositoryManager().removeRepository(emptyRepository.toURI());

		//delete any leftover data

		delete(emptyRepository);

	}

	/**

	 * Tests mirroring a repository to itself

	 * Source contains A, B

	 * Target contains A, B

	 * Expected is A, B

	 */

	public void testArtifactMirrorSourceIsDestination() {

		//Setup: Populate the repository

		runMirrorApplication("19.0", sourceRepoLocation, destRepoLocation, false);

		//run the application with the source and destination specified to the same place

		runMirrorApplication("19.1", destRepoLocation, destRepoLocation, true);

		try {

			//verify destination's content

			assertContentEquals("19.2", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("19.3", e);

		}

	}

	/**

	 * Tests mirroring a repository with a different version of the same package

	 * Source contains A, B (v1.0.1)

	 * Target contains A, B (v1.0.0)

	 * Expected is A, B (v1.0.0) and A, B (v1.0.1)

	 */

	public void testArtifactMirrorDifferentVersions() {

		//Setup: Populate the repository

		runMirrorApplication("20.0", sourceRepoLocation, destRepoLocation, false);

		//run the application with the source and destination specified to the same place

		runMirrorApplication("20.1", sourceRepo4Location, destRepoLocation, true);

		try {

			//verify destination's content

			assertContains("20.2", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContains("20.3", getArtifactRepositoryManager().loadRepository(sourceRepo4Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//checks that the destination has the correct number of keys (no extras)

			assertEquals("20.4", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null).getArtifactKeys().length + getArtifactRepositoryManager().loadRepository(sourceRepo4Location.toURI(), null).getArtifactKeys().length, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getArtifactKeys().length);

		} catch (ProvisionException e) {

			fail("20.5", e);

		}

	}

	/**

	 * Tests how mirror application handles an unspecified source

	 */

	public void testArtifactMirrorNullSource() {

		try {

			basicRunMirrorApplication("21.1", null, destRepoLocation.toURI());

			//We expect the ProvisionException to be thrown

			fail("21.3 ProvisionException not thrown");

		} catch (ProvisionException e) {

			return; //expected type of exception has been thrown

		} catch (Exception e) {

			fail("21.2", e);

		}

	}

	/**

	 * Tests how mirror application handles an unspecified destination

	 */

	public void testArtifactMirrorNullDestination() {

		try {

			basicRunMirrorApplication("22.1", sourceRepoLocation.toURI(), null);

			//We expect the ProvisionException to be thrown

			fail("22.3 ProvisionException not thrown");

		} catch (ProvisionException e) {

			return; //expected type of exception has been thrown

		} catch (Exception e) {

			fail("22.2", e);

		}

	}

	/**

	 * Tests how mirror application handles both an unspecified source and an unspecified destination

	 */

	public void testArtifactMirrorNullBoth() {

		try {

			basicRunMirrorApplication("23.0", null, null);

			//We expect the ProvisionException to be thrown

			fail("23.2 ProvisionException not thrown");

		} catch (ProvisionException e) {

			return; //expected type of exception has been thrown

		} catch (Exception e) {

			fail("23.1", e);

		}

	}

	/**

	 * Ensures that a repository created by the mirror application is a copy of the source

	 */

	public void testNewArtifactRepoProperties() {

		//run mirror application with source not preexisting

		artifactMirrorToEmpty("24.0", true, true);

		try {

			IArtifactRepository sourceRepository = getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null);

			IArtifactRepository destinationRepository = getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null);

			assertEquals("24.1", sourceRepository.getName(), destinationRepository.getName());

			assertRepositoryProperties("24.2", sourceRepository.getProperties(), destinationRepository.getProperties());

		} catch (ProvisionException e) {

			fail("24.3", e);

		}

	}

	/**

	 * Ensures that a repository created before the mirror application is run does not have its properties changed

	 */

	public void testExistingArtifactRepoProperties() {

		//Setup: create the destination

		String name = "Destination Name";

		Map properties = null; //default properties

		try {

			//create the repository and get the resulting properties

			properties = getArtifactRepositoryManager().createRepository(destRepoLocation.toURI(), name, IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, properties).getProperties();

		} catch (ProvisionException e) {

			fail("25.0", e);

		}

		//run the mirror application

		artifactMirrorToEmpty("25.2", true, false);

		try {

			IArtifactRepository repository = getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null);

			assertEquals("25.3", name, repository.getName());

			assertRepositoryProperties("25.4", properties, repository.getProperties());

		} catch (ProvisionException e) {

			fail("25.5", e);

		}

	}

	/**

	 *  * Ensures that a repository created by the mirror application has specified name

	 * For Bug 256909

	 */

	public void testNewArtifactRepoWithNewName() {

		String name = "Bug 256909 test - new";

		try {

			basicRunMirrorApplication("Bug 256909 Test", sourceRepoLocation.toURI(), destRepoLocation.toURI(), true, false, name);

		} catch (MalformedURLException e) {

			fail("Error creating URLs for Source/Detination", e);

		} catch (Exception e) {

			fail("Error running mirror application", e);

		}

		try {

			assertEquals("Assert name was set correct", name, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getName());

		} catch (ProvisionException e) {

			fail("Cannot obtain destination", e);

		}

	}

	/**

	 * Ensures that an existing destination used by the mirror application is given specified name

	 * For Bug 256909

	 */

	public void testExistingArtifactRepoWithNewName() {

		String oldName = "The original naem for Bug 256909 test - existing";

		String newName = "Bug 256909 test - existing";

		//Setup create the repository

		IArtifactRepository destinationRepo = null;

		try {

			destinationRepo = getArtifactRepositoryManager().createRepository(destRepoLocation.toURI(), oldName, IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		} catch (ProvisionException e) {

			fail("Error creating repo at destination", e);

		}

		assertEquals("Assert name is set correctly before mirror", oldName, destinationRepo.getName());

		try {

			MirrorApplication app = new MirrorApplication();

			app.addSource(createRepositoryDescriptor(sourceRepoLocation.toURI(), null, null, null));

			app.addDestination(createRepositoryDescriptor(destRepoLocation.toURI(), null, null, newName));

			//run the mirror application

			app.run(null);

		} catch (Exception e) {

			fail("Error running mirror application", e);

		}

		try {

			assertEquals("Assert name is set correctly after mirror", newName, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getName());

		} catch (ProvisionException e) {

			fail("Error loading destination", e);

		}

	}

	/**

	 * Verifies that the mirror application copies files (including packed files) correctly

	 */

	public void testArtifactFileCopying() {

		//Setup: load the repository containing packed data

		File packedRepoLocation = getTestData("26.0", "/testData/mirror/mirrorPackedRepo");

		try {

			basicRunMirrorApplication("26.1", packedRepoLocation.toURI(), destRepoLocation.toURI(), false, false);

		} catch (Exception e) {

			fail("26.3", e);

		}

		try {

			//Verify Contents

			assertContentEquals("26.4", getArtifactRepositoryManager().loadRepository(packedRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//Verify files on disk

			assertFileSizes("26.5", (SimpleArtifactRepository) getArtifactRepositoryManager().loadRepository(packedRepoLocation.toURI(), null), (SimpleArtifactRepository) getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

		} catch (ProvisionException e) {

			fail("26.6", e);

		}

	}

	/**

	 * Verifies that the mirror application executes processing steps correctly

	 */

	public void testArtifactProcessingSteps() {

		//Setup: load the repository containing packed data

		File packedRepoLocation = getTestData("27.0", "/testData/mirror/mirrorPackedRepo");

		IArtifactRepository packedRepo = null;

		IArtifactRepository destinationRepo = null;

		try {

			packedRepo = getArtifactRepositoryManager().loadRepository(packedRepoLocation.toURI(), null);

			destinationRepo = getArtifactRepositoryManager().createRepository(destRepoLocation.toURI(), "Test Repo", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		} catch (ProvisionException e1) {

			fail("");

		}

		IArtifactKey[] keys = packedRepo.getArtifactKeys();

		for (int i = 0; i < keys.length; i++) {

			IArtifactDescriptor[] srcDescriptors = packedRepo.getArtifactDescriptors(keys[i]);

			for (int j = 0; j < srcDescriptors.length; j++) {

				if (!(srcDescriptors[j].getProperty(IArtifactDescriptor.FORMAT) == null) && srcDescriptors[j].getProperty(IArtifactDescriptor.FORMAT).equals("packed")) {

					//if we have a packed artifact

					IArtifactDescriptor newDescriptor = new ArtifactDescriptor(keys[i]);

					Map properties = new OrderedProperties();

					properties.putAll(srcDescriptors[j].getProperties());

					properties.remove(IArtifactDescriptor.FORMAT);

					((ArtifactDescriptor) newDescriptor).addProperties(properties);

					//create appropriate descriptor

					try {

						OutputStream repositoryStream = null;

						try {

							//System.out.println("Mirroring: " + srcDescriptors[j].getArtifactKey() + " (Descriptor: " + srcDescriptors[j] + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

							repositoryStream = destinationRepo.getOutputStream(newDescriptor);

							if (repositoryStream == null)

								return;

							// TODO Is that ok to ignore the result?

							//TODO MAKE THIS WORK PROPERLY

							packedRepo.getArtifact(srcDescriptors[j], repositoryStream, new NullProgressMonitor());

						} finally {

							if (repositoryStream != null)

								repositoryStream.close();

						}

					} catch (ProvisionException e) {

						fail("27.1", e);

					} catch (IOException e) {

						fail("27.2", e);

					}

					//corresponding key should now be in the destination

					IArtifactDescriptor[] destDescriptors = destinationRepo.getArtifactDescriptors(keys[i]);

					boolean canonicalFound = false;

					for (int l = 0; !canonicalFound && (l < destDescriptors.length); l++) {

						//No processing steps mean item is canonical

						if (destDescriptors[l].getProcessingSteps().length == 0)

							canonicalFound = true;

					}

					if (!canonicalFound)

						fail("27.3 no canonical found for " + keys[i].toString());

					//ensure the canonical matches that in the expected

					assertFileSizes("27.3", (SimpleArtifactRepository) destinationRepo, (SimpleArtifactRepository) packedRepo);

				}

			}

		}

	}

	//for Bug 235683

	public void testMirrorCompressedSource() {

		File compressedSource = getTestData("0", "/testData/mirror/mirrorCompressedRepo");

		//Setup: get the artifacts.jar file

		File compressedArtifactsXML = new File(compressedSource.getAbsoluteFile() + "/artifacts.jar");

		//Setup: make sure artifacts.jar exists

		assertTrue("1", compressedArtifactsXML.exists());

		try {

			basicRunMirrorApplication("2", compressedSource.toURI(), destRepoLocation.toURI(), false, false);

		} catch (MalformedURLException e) {

			fail("3", e);

		} catch (Exception e) {

			fail("4", e);

		}

		//get the artifacts.jar file

		File destArtifactsXML = new File(destRepoLocation.getAbsolutePath() + "/artifacts.jar");

		//make sure artifacts.jar exists

		assertTrue("5", destArtifactsXML.exists());

	}

	//for Bug 235683

	public void testMirrorCompressedSourcetoUncompressedDestination() {

		File compressedSource = getTestData("0", "/testData/mirror/mirrorCompressedRepo");

		//Setup: get the artifacts.jar file

		File compressedArtifactsXML = new File(compressedSource.getAbsoluteFile() + "/artifacts.jar");

		//Setup: make sure artifacts.jar exists

		assertTrue("1", compressedArtifactsXML.exists());

		//Setup: create the destination

		try {

			String name = "Destination Name " + destRepoLocation;

			getArtifactRepositoryManager().createRepository(destRepoLocation.toURI(), name, IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		} catch (ProvisionException e) {

			fail("2", e);

		}

		assertTrue("2.1", new File(destRepoLocation, "artifacts.xml").exists());

		try {

			basicRunMirrorApplication("3", compressedSource.toURI(), destRepoLocation.toURI(), false, false);

		} catch (MalformedURLException e) {

			fail("4", e);

		} catch (Exception e) {

			fail("5", e);

		}

		//get the artifacts.jar file

		File destArtifactsXML = new File(destRepoLocation.getAbsolutePath() + "/artifacts.jar");

		//make sure artifacts.jar does not exist

		assertFalse("6", destArtifactsXML.exists());

		//get the artifacts.xml file

		destArtifactsXML = new File(destRepoLocation.getAbsolutePath() + "/artifacts.xml");

		//make sure artifacts.xml exists

		assertTrue("7", destArtifactsXML.exists());

	}

	//for Bug 235683

	public void testMirrorUncompressedSourceToCompressedDestination() {

		File uncompressedSource = getTestData("0", "/testData/mirror/mirrorPackedRepo");

		//Setup: get the artifacts.xml file

		File artifactsXML = new File(uncompressedSource.getAbsoluteFile() + "/artifacts.xml");

		//Setup: make sure artifacts.xml exists

		assertTrue("1", artifactsXML.exists());

		//Setup: create the destination

		try {

			String name = "Destination Name " + destRepoLocation;

			Map property = new HashMap();

			property.put(IRepository.PROP_COMPRESSED, "true");

			getArtifactRepositoryManager().createRepository(destRepoLocation.toURI(), name, IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, property);

		} catch (ProvisionException e) {

			fail("2", e);

		}

		assertTrue("2.1", new File(destRepoLocation, "artifacts.jar").exists());

		try {

			basicRunMirrorApplication("3", uncompressedSource.toURI(), destRepoLocation.toURI(), false, false);

		} catch (MalformedURLException e) {

			fail("4", e);

		} catch (Exception e) {

			fail("5", e);

		}

		//get the artifacts.jar file

		File destArtifactsXML = new File(destRepoLocation.getAbsolutePath() + "/artifacts.jar");

		//make sure artifacts.jar does exist

		assertTrue("6", destArtifactsXML.exists());

		//get the artifacts.xml file

		destArtifactsXML = new File(destRepoLocation.getAbsolutePath() + "/artifacts.xml");

		//make sure artifacts.xml does not exist

		assertFalse("7", destArtifactsXML.exists());

	}

	public void testMirrorApplicationWithCompositeSource() {

		//Setup Make composite repository

		File repoLocation = new File(getTempFolder(), "CompositeArtifactMirrorTest");

		AbstractProvisioningTest.delete(repoLocation);

		IArtifactRepository repo = null;

		try {

			repo = getArtifactRepositoryManager().createRepository(repoLocation.toURI(), "artifact name", IArtifactRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null);

		} catch (ProvisionException e) {

			fail("Could not create repository");

		}

		//ensure proper type of repository has been created

		if (!(repo instanceof CompositeArtifactRepository))

			fail("Repository is not a CompositeArtifactRepository");

		//Populate source

		File child1 = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");

		File child2 = getTestData("2", "/testData/mirror/mirrorSourceRepo2");

		((CompositeArtifactRepository) repo).addChild(child1.toURI());

		((CompositeArtifactRepository) repo).addChild(child2.toURI());

		runMirrorApplication("Mirroring from Composite Source", repoLocation, destRepoLocation, false);

		try {

			assertContentEquals("Verifying contents", repo, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//Verify that result is the same as mirroring from the 2 repositories separately

			assertContains("3", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			assertContains("4", getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null), getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null));

			//checks that the destination has the correct number of keys (no extras)

			assertEquals("5", getArtifactRepositoryManager().loadRepository(sourceRepoLocation.toURI(), null).getArtifactKeys().length + getArtifactRepositoryManager().loadRepository(sourceRepo2Location.toURI(), null).getArtifactKeys().length, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getArtifactKeys().length);

		} catch (ProvisionException e) {

			fail("Could not load destination", e);

		}

	}

	//for Bug 250527

	public void testIgnoreErrorsArgument() {

		//Error prints to stderr, redirect that to a file

		PrintStream oldErr = System.err;

		PrintStream newErr = null;

		try {

			destRepoLocation.mkdir();

			newErr = new PrintStream(new FileOutputStream(new File(destRepoLocation, "sys.err")));

		} catch (FileNotFoundException e) {

			fail("Error redirecting outputs", e);

		}

		System.setErr(newErr);

		//run test without verbose

		mirrorWithError(false);

		System.setErr(oldErr);

		newErr.close();

		try {

			assertEquals("Verifying correct number of Keys", 1, getArtifactRepositoryManager().loadRepository(destRepoLocation.toURI(), null).getArtifactKeys().length);

			//Because only 1 of the artifacts exists on disk, the number of artifacts in the destination should only be 1.

			//Order in which mirror application mirrors artifacts is random.

		} catch (ProvisionException e) {

			fail("Error laoding destiantion repo", e);

		}

	}

	public void testCompareUsingMD5Comparator() {

		//Setup create descriptors with different md5 values

		IArtifactKey dupKey = PublisherHelper.createBinaryArtifactKey("testKeyId", new Version("1.2.3"));

		File artifact1 = getTestData("0.0", "/testData/mirror/mirrorSourceRepo1 with space/artifacts.xml");

		File artifact2 = getTestData("0.0", "/testData/mirror/mirrorSourceRepo2/artifacts.xml");

		IArtifactDescriptor descriptor1 = PublisherHelper.createArtifactDescriptor(dupKey, artifact1);

		IArtifactDescriptor descriptor2 = PublisherHelper.createArtifactDescriptor(dupKey, artifact2);

		assertEquals("Ensuring Descriptors are the same", descriptor1, descriptor2);

		assertNotSame("Ensuring MD5 values are different", descriptor1.getProperty(IArtifactDescriptor.DOWNLOAD_MD5), descriptor2.getProperty(IArtifactDescriptor.DOWNLOAD_MD5));

		//Setup make repositories

		File repo1Location = getTestFolder(getUniqueString());

		File repo2Location = getTestFolder(getUniqueString());

		IArtifactRepository repo1 = null;

		IArtifactRepository repo2 = null;

		try {

			repo1 = getArtifactRepositoryManager().createRepository(repo1Location.toURI(), "Repo 1", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

			repo1.addDescriptor(descriptor1);

			repo2 = getArtifactRepositoryManager().createRepository(repo2Location.toURI(), "Repo 2", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

			repo2.addDescriptor(descriptor2);

		} catch (ProvisionException e) {

			fail("Error creating repositories", e);

		}

		//Comparator prints to stderr, redirect that to a file

		PrintStream oldErr = System.err;

		PrintStream newErr = null;

		PrintStream oldOut = System.out;

		PrintStream newOut = null;

		try {

			newErr = new PrintStream(new FileOutputStream(new File(repo2Location, "sys.err")));

			newOut = new PrintStream(new FileOutputStream(new File(repo2Location, "sys.out")));

		} catch (FileNotFoundException e) {

			fail("Error redirecting outputs", e);

		}

		System.setErr(newErr);

		System.setOut(newOut);

		MirrorApplication app = null;

		try {

			app = new MirrorApplication();

			app.addSource(createRepositoryDescriptor(repo1Location.toURI(), null, null, null));

			app.addDestination(createRepositoryDescriptor(repo2Location.toURI(), null, null, null));

			app.setVerbose(true);

			//Set compare flag.

			app.setCompare(true);

			//run the mirror application

			app.run(null);

		} catch (Exception e) {

			fail("Running mirror application with duplicate descriptors with different md5 values failed", e);

		}

		System.setErr(oldErr);

		newErr.close();

		System.setOut(oldOut);

		newOut.close();

		IArtifactDescriptor[] destDescriptors = repo2.getArtifactDescriptors(descriptor2.getArtifactKey());

		assertEquals("Ensuring destination has correct number of descriptors", 1, destDescriptors.length);

		assertEquals("Ensuring proper descriptor exists in destination", descriptor2.getProperty(IArtifactDescriptor.DOWNLOAD_MD5), destDescriptors[0].getProperty(IArtifactDescriptor.DOWNLOAD_MD5));

		String msg = NLS.bind(Messages.warning_differentMD5, new Object[] {getCompositeSourceRepo(app), repo2, descriptor1});

		try {

			assertLogContainsLine(TestActivator.getLogFile(), msg);

		} catch (Exception e) {

			fail("error verifying output", e);

		}

	}

	public void testBaselineCompareUsingMD5Comparator() {

		//Setup create descriptors with different md5 values

		IArtifactKey dupKey = PublisherHelper.createBinaryArtifactKey("testKeyId", new Version("1.2.3"));

		File artifact1 = getTestData("0.0", "/testData/mirror/mirrorSourceRepo1 with space/content.xml");

		File artifact2 = getTestData("0.0", "/testData/mirror/mirrorSourceRepo2/content.xml");

		//Setup Copy the file to the baseline

		File repoLocation = getTestFolder(getUniqueString());

		File baselineLocation = getTestFolder(getUniqueString());

		File baselineBinaryDirectory = new File(baselineLocation, "binary");

		baselineBinaryDirectory.mkdir();

		File baselineContentLocation = new File(baselineBinaryDirectory, "testKeyId_1.2.3");

		AbstractProvisioningTest.copy("Copying File to baseline", artifact2, baselineContentLocation);

		IArtifactDescriptor descriptor1 = PublisherHelper.createArtifactDescriptor(dupKey, artifact1);

		IArtifactDescriptor descriptor2 = PublisherHelper.createArtifactDescriptor(dupKey, baselineContentLocation);

		assertEquals("Ensuring Descriptors are the same", descriptor1, descriptor2);

		assertNotSame("Ensuring MD5 values are different", descriptor1.getProperty(IArtifactDescriptor.DOWNLOAD_MD5), descriptor2.getProperty(IArtifactDescriptor.DOWNLOAD_MD5));

		//Setup make repositories

		IArtifactRepository repo = null;

		IArtifactRepository baseline = null;

		try {

			repo = getArtifactRepositoryManager().createRepository(repoLocation.toURI(), "Repo 1", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

			repo.addDescriptor(descriptor1);

			baseline = getArtifactRepositoryManager().createRepository(baselineLocation.toURI(), "Repo 2", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

			baseline.addDescriptor(descriptor2);

		} catch (ProvisionException e) {

			fail("Error creating repositories", e);

		}

		//Comparator prints to stderr, redirect that to a file

		PrintStream oldErr = System.err;

		PrintStream newErr = null;

		PrintStream oldOut = System.out;

		PrintStream newOut = null;

		try {

			destRepoLocation.mkdir();

			newErr = new PrintStream(new FileOutputStream(new File(destRepoLocation, "sys.err")));

			newOut = new PrintStream(new FileOutputStream(new File(destRepoLocation, "sys.out")));

		} catch (FileNotFoundException e) {

			fail("Error redirecting outputs", e);

		}

		System.setErr(newErr);

		System.setOut(newOut);

		MirrorApplication app = null;

		try {

			app = new MirrorApplication();

			app.addSource(createRepositoryDescriptor(repoLocation.toURI(), null, null, null));

			app.addDestination(createRepositoryDescriptor(destRepoLocation.toURI(), null, null, null));

			//Set baseline

			app.setBaseline(baselineLocation.toURI());