<antTask

            class="org.eclipse.equinox.p2.internal.repository.tools.tasks.ModifyRepositoryChildrenTask"

            library="lib/repository-tools-ant.jar"

            name="p2.modify.composite.repository.children">

      </antTask>

     <antTask

            class="org.eclipse.equinox.p2.internal.repository.tools.tasks.CreateCompositeRepositoryTask"

            library="lib/repository-tools-ant.jar"

            name="p2.create.composite.repository">

      </antTask>

import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;

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

	public static final int TYPE_BOTH = -1;

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

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

import org.eclipse.osgi.util.NLS;

	protected boolean removeUnknownRepositories = true;

	protected List sourceRepositories = new ArrayList();

		for (Iterator iter = sourceRepositories.iterator(); iter.hasNext();) {

			RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();

			if (repo.getKind() == IRepository.TYPE_ARTIFACT) {

				sourceArtifactRepositories.add(repo.getRepoLocation());

			} else if (repo.getKind() == IRepository.TYPE_METADATA) {

				sourceMetadataRepositories.add(repo.getRepoLocation());

			} else if (repo.getKind() == RepositoryDescriptor.TYPE_BOTH) {

				sourceArtifactRepositories.add(repo.getRepoLocation());

				sourceMetadataRepositories.add(repo.getRepoLocation());

			} else

				throw new ProvisionException(NLS.bind(Messages.unknown_repo_type, repo.getRepoLocation()));

		}

	public void addSource(RepositoryDescriptor repo) {

		sourceRepositories.add(repo);

	}

	public static String CompositeRepository_default_artifactRepo_name;

	public static String CompositeRepository_default_metadataRepo_name;

	public static String no_destination_repo;

	public static String unknown_repo_type;

CompositeRepository_default_metadataRepo_name=Composite Metadata Repository

CompositeRepository_default_artifactRepo_name=Composite Artifact Repository

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

 * Copyright (c) 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.internal.repository.tools.tasks;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import org.eclipse.core.runtime.IStatus;

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

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

public class AntMirrorLog {

	private boolean consoleMessage = false;

	private Method log;

	private Object task;

	public AntMirrorLog(Object task) throws NoSuchMethodException {

		this.task = task;

		try {

			log = task.getClass().getMethod("log", new Class[] {String.class, int.class}); //$NON-NLS-1$

		} catch (SecurityException e) {

			exceptionOccurred(null, e);

		}

	}

	public void log(IArtifactDescriptor descriptor, IStatus status) {

		log(descriptor.toString(), status.getSeverity());

		log(status);

	}

	public void log(IStatus status) {

		int severity = status.getSeverity();

		// Log the status message

		log(status.getMessage(), severity);

		// Log the exception if applicable

		if (status.getException() != null)

			log(status.getException().getMessage(), severity);

		// Log any children of this status

		IStatus[] nestedStatus = status.getChildren();

		if (nestedStatus != null)

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

				log(nestedStatus[i]);

	}

	public void close() {

		// nothing to do here

	}

	/*

	 * Log a message to the Ant Task

	 */

	private void log(String message, int statusSeverity) {

		try {

			log.invoke(task, new Object[] {message, new Integer(mapLogLevels(statusSeverity))});

		} catch (IllegalArgumentException e) {

			exceptionOccurred(message, e);

		} catch (IllegalAccessException e) {

			exceptionOccurred(message, e);

		} catch (InvocationTargetException e) {

			exceptionOccurred(message, e);

		}

	}

	/*

	 * Show an error message if this the first time, and print status messages.

	 */

	private void exceptionOccurred(String message, Exception e) {

		if (!consoleMessage) {

			System.err.println(Messages.MirrorLog_Exception_Occurred);

			e.printStackTrace(System.err);

			System.err.println(Messages.MirrorLog_Console_Log);

			consoleMessage = true;

		}

		if (message != null)

			System.out.println(message);

	}

	/**

	 * Copied from AntLogAdapter in pde build.

	 */

	private int mapLogLevels(int iStatusLevel) {

		switch (iStatusLevel) {

			case IStatus.ERROR :

				return 0;

			case IStatus.OK :

				return 2;

			case IStatus.INFO :

				return 2;

			case IStatus.WARNING :

				return 1;

			default :

				return 1;

		}

	}

}

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

 * Copyright (c) 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.internal.repository.tools.tasks;

import java.util.Iterator;

import org.apache.tools.ant.BuildException;

import org.apache.tools.ant.Task;

import org.eclipse.core.runtime.IStatus;

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

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

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

public class CreateCompositeRepositoryTask extends Task {

	CreateCompositeRepositoryApplication createApp;

	ModifyCompositeRepositoryApplication modifyApp;

	boolean add = false;

	public CreateCompositeRepositoryTask() {

		createApp = new CreateCompositeRepositoryApplication();

		modifyApp = new ModifyCompositeRepositoryApplication();

		modifyApp.setRemoveUnknownRepositories(false);

	}

	/* (non-Javadoc)

	 * @see org.apache.tools.ant.Task#execute()

	 */

	public void execute() throws BuildException {

		try {

			IStatus result = createApp.run(null);

			if (result.matches(IStatus.ERROR)) {

				throw new BuildException(TaskHelper.statusToString(result, null).toString());

			}

			if (add) {

				result = modifyApp.run(null);

				if (result.matches(IStatus.ERROR)) {

					throw new BuildException(TaskHelper.statusToString(result, null).toString());

				}

			}

		} catch (ProvisionException e) {

			throw new BuildException(e);

		}

	}

	/*

	 * Add a repository to create

	 */

	public DestinationRepository createRepository() {

		DestinationRepository repo = new DestinationRepository();

		createApp.addRepository(repo.getDescriptor());

		modifyApp.addDestination(repo.getDescriptor());

		return repo;

	}

	/*

	 * Set whether the task should fail if the repository already exists

	 */

	public void setFailOnExists(boolean value) {

		createApp.setFailOnExists(value);

	}

	/*

	 * Add a list of child repositories to add to the newly created repository

	 */

	public void addConfiguredAdd(RepositoryList addList) {

		add = true;

		for (Iterator iter = addList.getRepositoryList().iterator(); iter.hasNext();) {

			DestinationRepository repo = (DestinationRepository) iter.next();

			modifyApp.addChild(repo.getDescriptor());

		}

	}

}

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

 * Copyright (c) 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.internal.repository.tools.tasks;

import org.apache.tools.ant.types.FileSet;

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

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

public class RepositoryFileSet extends FileSet {

	public final static int TYPE_BOTH = RepositoryDescriptor.TYPE_BOTH;

	public final static int TYPE_ARTIFACT = IRepository.TYPE_ARTIFACT;

	public final static int TYPE_METADATA = IRepository.TYPE_METADATA;

	int kind = TYPE_BOTH;

	public void setKind(String repoKind) {

		if (repoKind.startsWith("m") || repoKind.startsWith("M")) //$NON-NLS-1$//$NON-NLS-2$

			kind = IRepository.TYPE_METADATA;

		if (repoKind.startsWith("a") || repoKind.startsWith("A")) //$NON-NLS-1$//$NON-NLS-2$

			kind = IRepository.TYPE_ARTIFACT;

	}

	public int getKind() {

		return kind;

	}

}

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

 * Copyright (c) 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.ant;

import java.io.*;

import java.net.URI;

import java.util.Iterator;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.URIUtil;

import org.eclipse.equinox.internal.p2.metadata.InstallableUnit;

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.metadata.IInstallableUnit;

import org.eclipse.equinox.internal.provisional.p2.metadata.query.InstallableUnitQuery;

import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;

import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepositoryManager;

import org.eclipse.equinox.internal.provisional.p2.query.Collector;

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

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

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

import org.eclipse.osgi.util.NLS;

public class MirrorTaskTest extends AbstractAntProvisioningTest {

	private URI destinationRepo;

	private URI sourceRepo2;

	public void setUp() throws Exception {

		super.setUp();

		// Get a random location to create a repository

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

		sourceRepo2 = getTestData("loading error data", "testData/mirror/mirrorSourceRepo2").toURI();

	}

	public void tearDown() throws Exception {

		// Remove repository manager references

		getArtifactRepositoryManager().removeRepository(destinationRepo);

		getMetadataRepositoryManager().removeRepository(destinationRepo);

		getArtifactRepositoryManager().removeRepository(sourceRepo2);

		getMetadataRepositoryManager().removeRepository(sourceRepo2);

		// Cleanup disk

		delete(new File(destinationRepo));

		super.tearDown();

	}

	/*

	 * Test that all IUs can be mirrored

	 */

	public void testMirrorAllIUSpecified() throws ProvisionException {

		AntTaskElement mirror = createMirrorTask();

		mirror.addElement(createSourceElement(sourceRepo2, sourceRepo2));

		addAllIUs(mirror, getMetadataRepositoryManager().loadRepository(sourceRepo2, null));

		runAntTask();

		try {

			assertEquals("Different number of Artifact Keys", getArtifactKeyCount(sourceRepo2), getArtifactKeyCount(destinationRepo));

			assertEquals("Different number of IUs", getIUCount(sourceRepo2), getIUCount(destinationRepo));

		} catch (ProvisionException e) {

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

		}

	}

	/*

	 * Test that we only mirror specified IUs & Artifacts

	 */

	public void testMirrorSomeIUSpecified() {

		AntTaskElement mirror = createMirrorTask();

		mirror.addElement(createSourceElement(sourceRepo2, sourceRepo2));

		mirror.addElement(createIUElement("anotherplugin", "1.0.0"));

		runAntTask();

		try {

			assertEquals("Wrong number of Artifact Keys", 1, getArtifactKeyCount(destinationRepo));

			assertEquals("Wrong number of IUs", 1, getIUCount(destinationRepo));

		} catch (ProvisionException e) {

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

		}

	}

	/*

	 * Test that the proper exception is thrown when no IU is provided

	 */

	public void testMirrorNoIUNoRepo() {

		AntTaskElement mirror = createMirrorTask();

		mirror.addElement(createSourceElement(sourceRepo2, null));

		Exception exception = null;

		try {

			runAntTaskWithExceptions();

		} catch (CoreException e) {

			exception = e;

		}

		if (exception == null)

			fail("No exception thrown");

		if (!(rootCause(exception) instanceof ProvisionException) && !rootCause(exception).getMessage().contains("No IUs"))

			fail("Exception is of an unexpected type or message", rootCause(exception));

	}

	/*

	 * Test that all IUs are mirrored when none are specified

	 */

	public void testMirrorNoIUSpecified() {

		AntTaskElement mirror = createMirrorTask();

		mirror.addElement(createSourceElement(sourceRepo2, sourceRepo2));

		runAntTask();

		try {

			assertEquals("Different number of Artifact Keys", getArtifactKeyCount(sourceRepo2), getArtifactKeyCount(destinationRepo));

			assertEquals("Different number of IUs", getIUCount(sourceRepo2), getIUCount(destinationRepo));

		} catch (ProvisionException e) {

			fail("Failed to load Repository", 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 = createAndAddIU(repoLocation.toURI(), descriptor1);

			baseline = createAndAddIU(baselineLocation.toURI(), 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 {

			(new File(destinationRepo)).mkdir();

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

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

		} catch (FileNotFoundException e) {

			fail("Error redirecting outputs", e);

		}

		try {

			System.setErr(newErr);

			System.setOut(newOut);

			AntTaskElement mirror = createMirrorTask();

			mirror.addElement(createSourceElement(repoLocation.toURI(), repoLocation.toURI()));

			mirror.addAttribute("baseline", URIUtil.toUnencodedString(baselineLocation.toURI()));

			mirror.addAttribute("verbose", String.valueOf(true));

			mirror.addAttribute("compare", String.valueOf(true));

			runAntTaskWithExceptions();

			//Set compareAgaist

			//String[] args = new String[] {"-source", repoLocation.toURL().toExternalForm(), "-destination", destinationRepo.toURL().toExternalForm(), "-compareAgainst", baselineLocation.toURL().toExternalForm(), "-verbose", "-compare"};

			//run the mirror application

			//runMirrorApplication("Running with baseline compare", args);

		} catch (Exception e) {

			fail("Running mirror application with baseline compare", rootCause(e));

		} finally {

			System.setErr(oldErr);

			newErr.close();

			System.setOut(oldOut);

			newOut.close();

		}

		IArtifactRepository destination = null;

		try {

			destination = getArtifactRepositoryManager().loadRepository(destinationRepo, null);

		} catch (ProvisionException e) {

			fail("Error loading destination", e);

		}

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

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

		assertEquals("Ensuring destination contains the descriptor from the baseline", descriptor2.getProperty(IArtifactDescriptor.DOWNLOAD_MD5), destDescriptors[0].getProperty(IArtifactDescriptor.DOWNLOAD_MD5));

		String msg = NLS.bind("have different MD5 sums for {2}", new Object[] {baseline, repo, descriptor1});

		assertLogContains(msg);

	}

	/*

	 * Create an IU for a descriptor and the IU+descriptor to the specified repo

	 */

	protected IArtifactRepository createAndAddIU(URI repoLocation, IArtifactDescriptor descriptor) throws ProvisionException {

		IArtifactRepository artifactRepo = getArtifactRepositoryManager().createRepository(repoLocation, "Repo 1", IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		artifactRepo.addDescriptor(descriptor);

		IMetadataRepository metaRepo = getMetadataRepositoryManager().createRepository(repoLocation, "Repo", IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);

		InstallableUnit iu = new InstallableUnit();

		iu.setId(descriptor.getArtifactKey().getId() + "IU");

		iu.setVersion(descriptor.getArtifactKey().getVersion());

		iu.setArtifacts(new IArtifactKey[] {descriptor.getArtifactKey()});

		metaRepo.addInstallableUnits(new IInstallableUnit[] {iu});

		return artifactRepo;

	}

	/*

	 * Get the number of artifact keys in a repository

	 */

	protected int getArtifactKeyCount(URI location) throws ProvisionException {

		return getArtifactRepositoryManager().loadRepository(location, null).getArtifactKeys().length;

	}

	/*

	 * Get the number of IUs in a repository

	 */

	protected int getIUCount(URI location) throws ProvisionException {

		return getMetadataRepositoryManager().loadRepository(location, null).query(InstallableUnitQuery.ANY, new Collector(), null).size();

	}

	/*

	 * Add all IUs to the parent element

	 */

	protected void addAllIUs(AntTaskElement parent, IMetadataRepository repo) {

		Collector collector = repo.query(InstallableUnitQuery.ANY, new Collector(), null);

		for (Iterator iter = collector.iterator(); iter.hasNext();) {

			IInstallableUnit iu = (IInstallableUnit) iter.next();

			parent.addElement(createIUElement(iu.getId(), iu.getVersion().toString()));

		}

	}

	/*

	 * Create an element from the specified information

	 */

	protected AntTaskElement createIUElement(String id, String version) {

		AntTaskElement iu = new AntTaskElement("iu");

		iu.addAttributes(new String[] {"id", id, "version", version});

		return iu;

	}

	/*

	 * Create the base mirror task & add it to the script

	 */

	protected AntTaskElement createMirrorTask() {

		AntTaskElement mirror = new AntTaskElement("p2.mirror");

		mirror.addElement(getRepositoryElement(destinationRepo, null));

		addTask(mirror);

		return mirror;

	}

	/*

	 * Create a source element with the specified repositories

	 */

	protected AntTaskElement createSourceElement(URI artifact, URI metadata) {

		AntTaskElement source = new AntTaskElement("source");

		if (artifact != null)

			source.addElement(getRepositoryElement(artifact, AbstractAntProvisioningTest.TYPE_ARTIFACT));

		if (metadata != null)

			source.addElement(getRepositoryElement(metadata, AbstractAntProvisioningTest.TYPE_METADATA));

		return source;

	}

}

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

 * Copyright (c) 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.ant;

import java.io.File;

import java.net.URI;

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

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

import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;

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

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

import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepositoryManager;

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

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

public class ModifyCompositeRepositoryTaskTest extends AbstractAntProvisioningTest {

	private static final String ADD_ELEMENT = "add";

	private static final String REMOVE_ELEMENT = "remove";

	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 testAddChildArtifact() throws Exception {

		// Create repository

		createCompositeRepository(TYPE_ARTIFACT);

		// Create the modify repository task

		AntTaskElement modify = createModifyElement(TYPE_ARTIFACT);

		addTask(modify);

		// Create the Add element

		AntTaskElement add = new AntTaskElement(ADD_ELEMENT);

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

		modify.addElement(add);

		// Run the task

		runAntTask();

		CompositeArtifactRepository repo = (CompositeArtifactRepository) getCompositeRepository(TYPE_ARTIFACT);

		assertTrue("Repository does not contain child", repo.getChildren().contains(HTTP_SITE));

	}

	public void testAddChildMetadata() {

		// Create repository

		createCompositeRepository(TYPE_METADATA);

		// Create the modify repository task

		AntTaskElement modify = createModifyElement(TYPE_METADATA);

		addTask(modify);

		// Create the Add element

		AntTaskElement add = new AntTaskElement(ADD_ELEMENT);

		add.addElement(getRepositoryElement(HTTP_SITE, TYPE_METADATA));

		modify.addElement(add);

		// Run the task

		runAntTask();

		CompositeMetadataRepository repo = (CompositeMetadataRepository) getCompositeRepository(TYPE_METADATA);

		assertTrue("Repository does not contain child", repo.getChildren().contains(HTTP_SITE));

	}

	public void testAddChildBoth() {

		// Create repository

		createCompositeRepository(null);

		// Create the modify repository task

		AntTaskElement modify = createModifyElement(null);

		addTask(modify);

		// Create the Add element

		AntTaskElement add = createAddElement(null, new URI[] {HTTP_SITE});

		modify.addElement(add);

		// Run the task

		runAntTask();

		CompositeArtifactRepository artifactRepo = (CompositeArtifactRepository) getCompositeRepository(TYPE_ARTIFACT);

		assertTrue("Repository does not contain child", artifactRepo.getChildren().contains(HTTP_SITE));

		CompositeMetadataRepository metadataRepo = (CompositeMetadataRepository) getCompositeRepository(TYPE_METADATA);

		assertTrue("Repository does not contain child", metadataRepo.getChildren().contains(HTTP_SITE));

	}

	public void testRemoveAllChildren() {

		// Create repository

		ICompositeRepository parent = createCompositeRepository(TYPE_ARTIFACT);

		parent.addChild(HTTP_SITE);

		// Create the modify repository task

		AntTaskElement modify = createModifyElement(TYPE_ARTIFACT);

		addTask(modify);

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

		// Run the task

		runAntTask();

		CompositeArtifactRepository artifactRepo = (CompositeArtifactRepository) getCompositeRepository(TYPE_ARTIFACT);

		assertTrue("Children not removed", artifactRepo.getChildren().isEmpty());

	}

	public void testRemoveChild() {

		createCompositeRepository(TYPE_ARTIFACT);

		AntTaskElement modify = createModifyElement(TYPE_ARTIFACT);

		addTask(modify);

		AntTaskElement add = createAddElement(TYPE_ARTIFACT, new URI[] {HTTP_SITE});

		modify.addElement(add);

		modify = createModifyElement(TYPE_ARTIFACT);

		addTask(modify);

		AntTaskElement remove = createRemoveElement(TYPE_ARTIFACT, new URI[] {HTTP_SITE});

		modify.addElement(remove);

		runAntTask();

		CompositeArtifactRepository repo = (CompositeArtifactRepository) getCompositeRepository(TYPE_ARTIFACT);

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

	}

	protected ICompositeRepository getCompositeRepository(String type) {

		try {

			if (type == TYPE_ARTIFACT) {

				return (ICompositeRepository) getArtifactRepositoryManager().loadRepository(compositeSite, null);

			} else if (type == TYPE_METADATA)

				return (ICompositeRepository) getMetadataRepositoryManager().loadRepository(compositeSite, null);

			else

				fail("No type specified");

		} catch (ProvisionException e) {

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

		} catch (ClassCastException e) {

			fail("Repository is not composite", e);

		}

		// Will not occur

		return null;

	}

	protected AntTaskElement createRemoveElement(String type, URI[] addresses) {

		AntTaskElement add = new AntTaskElement(REMOVE_ELEMENT);

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

			add.addElement(getRepositoryElement(addresses[i], type));

		return add;

	}

	protected AntTaskElement createAddElement(String type, URI[] addresses) {

		AntTaskElement add = new AntTaskElement(ADD_ELEMENT);

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

			add.addElement(getRepositoryElement(addresses[i], type));

		return add;

	}

	protected AntTaskElement createModifyElement(String type) {

		AntTaskElement modifyCompositeTask = new AntTaskElement("p2.modify.composite.repository.children");

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

		return modifyCompositeTask;

	}

	protected ICompositeRepository createCompositeRepository(String type) {

		ICompositeRepository repo = null;

		try {

			if (TYPE_ARTIFACT.equals(type) || type == null) {

				repo = (ICompositeRepository) RepositoryHelper.validDestinationRepository(getArtifactRepositoryManager().createRepository(compositeSite, "Test Composite Repo", IArtifactRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null));

			}

			if (TYPE_METADATA.equals(type) || type == null) {

				repo = (ICompositeRepository) RepositoryHelper.validDestinationRepository(getMetadataRepositoryManager().createRepository(compositeSite, "Test Composite Repo", IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null));

			}

		} catch (ProvisionException e) {

			fail("Failed to create composite repository", e);

		} catch (IllegalStateException e) {

			fail("failed to create writeable composite repository", e);

		}

		return repo;

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

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

		addTask(createCompositeTask);*/

	}

}