/*******************************************************************************
* Copyright (c) 2008, 2010 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
* Code 9 - ongoing development
* EclipseSource - ongoing development
*******************************************************************************/
package org.eclipse.equinox.p2.tests.metadata.repository;
import java.io.File;
import java.io.PrintStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.URIUtil;
import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository;
import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepositoryFactory;
import org.eclipse.equinox.internal.p2.persistence.CompositeRepositoryState;
import org.eclipse.equinox.p2.core.ProvisionException;
import org.eclipse.equinox.p2.metadata.*;
import org.eclipse.equinox.p2.metadata.MetadataFactory.InstallableUnitDescription;
import org.eclipse.equinox.p2.query.*;
import org.eclipse.equinox.p2.repository.IRepository;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepositoryManager;
import org.eclipse.equinox.p2.tests.*;
import org.eclipse.equinox.p2.tests.core.CompoundQueryableTest.CompoundQueryTestProgressMonitor;
/**
* Test API of the local metadata repository implementation.
*/
public class CompositeMetadataRepositoryTest extends AbstractProvisioningTest {
private static final String TEST_KEY = "TestKey";
private static final String TEST_VALUE = "TestValue";
protected File repoLocation;
protected void setUp() throws Exception {
super.setUp();
repoLocation = new File(getTempFolder(), "CompositeMetadataRepositoryTest");
AbstractProvisioningTest.delete(repoLocation);
}
protected void tearDown() throws Exception {
getMetadataRepositoryManager().removeRepository(repoLocation.toURI());
delete(repoLocation);
super.tearDown();
}
public void testCompressedRepositoryCreation() {
createRepo(true);
File[] files = repoLocation.listFiles();
boolean jarFilePresent = false;
boolean xmlFilePresent = false;
// one of the files in the repository should be the content.xml.jar
for (int i = 0; i < files.length; i++) {
if ("compositeContent.jar".equalsIgnoreCase(files[i].getName())) {
jarFilePresent = true;
}
if ("compositeContent.xml".equalsIgnoreCase(files[i].getName())) {
xmlFilePresent = true;
}
}
if (!jarFilePresent) {
fail("Repository did not create JAR for compositeContent.xml");
}
if (xmlFilePresent) {
fail("Repository should not create compositeContent.xml");
}
}
public void testUncompressedRepositoryCreation() {
createRepo(false);
File[] files = repoLocation.listFiles();
boolean jarFilePresent = false;
// none of the files in the repository should be the content.xml.jar
for (int i = 0; i < files.length; i++) {
if ("compositeContent.jar".equalsIgnoreCase(files[i].getName())) {
jarFilePresent = true;
}
}
if (jarFilePresent) {
fail("Repository should not create JAR for compositeContent.xml");
}
}
public void testAddInstallableUnits() {
//create uncommpressed repo
CompositeMetadataRepository compRepo = createRepo(false);
//Try to add a new InstallableUnit.
try {
InstallableUnitDescription descriptor = new MetadataFactory.InstallableUnitDescription();
descriptor.setId("testIuId");
descriptor.setVersion(Version.create("3.2.1"));
IInstallableUnit iu = MetadataFactory.createInstallableUnit(descriptor);
compRepo.addInstallableUnits(Arrays.asList(iu));
fail("Should not be able to insert InstallableUnit");
} catch (UnsupportedOperationException e) {
//expected. fall through
}
}
public void testRemoveInstallableUnits() {
//create uncommpressed repo
CompositeMetadataRepository compRepo = createRepo(false);
//Try to remove an InstallableUnit.
try {
IQueryResult queryResult = compRepo.query(QueryUtil.createIUAnyQuery(), null);
compRepo.removeInstallableUnits(queryResult.toSet());
fail("Should not be able to remove InstallableUnit");
} catch (UnsupportedOperationException e) {
//expected. fall through
}
}
public void testRemoveAll() {
//create uncommpressed repo
CompositeMetadataRepository compRepo = createRepo(false);
//Try to removeAll.
try {
compRepo.removeAll();
fail("Should not be able to removeAll()");
} catch (UnsupportedOperationException e) {
//expected. fall through
}
}
public void testGetProperties() {
IMetadataRepositoryManager manager = getMetadataRepositoryManager();
IMetadataRepository repo = null;
try {
repo = manager.createRepository(repoLocation.toURI(), "TestRepo", IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null);
} catch (ProvisionException e) {
fail("Cannot create repository: ", e);
}
Map properties = repo.getProperties();
//attempting to modify the properties should fail
try {
properties.put(TEST_KEY, TEST_VALUE);
fail("Should not allow setting property");
} catch (RuntimeException e) {
//expected
}
}
public void testSetProperty() {
IMetadataRepositoryManager manager = getMetadataRepositoryManager();
IMetadataRepository repo = null;
try {
repo = manager.createRepository(repoLocation.toURI(), "TestRepo", IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null);
} catch (ProvisionException e) {
fail("Cannot create repository: ", e);
}
Map properties = repo.getProperties();
assertTrue("1.0", !properties.containsKey(TEST_KEY));
repo.setProperty(TEST_KEY, TEST_VALUE);
//the previously obtained properties should not be affected by subsequent changes
assertTrue("1.1", !properties.containsKey(TEST_KEY));
properties = repo.getProperties();
assertTrue("1.2", properties.containsKey(TEST_KEY));
//going back to repo manager, should still get the new property
try {
repo = manager.loadRepository(repoLocation.toURI(), null);
} catch (ProvisionException e) {
fail("Cannot load repository: ", e);
}
properties = repo.getProperties();
assertTrue("1.3", properties.containsKey(TEST_KEY));
//setting a null value should remove the key
repo.setProperty(TEST_KEY, null);
properties = repo.getProperties();
assertTrue("1.4", !properties.containsKey(TEST_KEY));
}
public void testAddChild() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
File child = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
IMetadataRepositoryManager metadataRepositoryManager = getMetadataRepositoryManager();
IMetadataRepository repo = null;
try {
repo = metadataRepositoryManager.loadRepository(child.toURI(), null);
} catch (ProvisionException e) {
fail("Unable to load repository for verification", e);
}
assertContentEquals("Verifying contents", compRepo, repo);
}
public void testRemoveChild() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
//Setup, populate the children
File child = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
compRepo.removeChild(child.toURI());
assertEquals("Children size after remove", 0, compRepo.getChildren().size());
}
public void testAddRepeatChild() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
File child = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
//Add the same repo again
compRepo.addChild(child.toURI());
//size should not change
assertEquals("Children size after repeat entry", 1, compRepo.getChildren().size());
}
public void testAddMultipleChildren() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
File child1 = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child1.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
File child2 = getTestData("2", "/testData/mirror/mirrorSourceRepo2");
compRepo.addChild(child2.toURI());
assertEquals("Children size with 2 children", 2, compRepo.getChildren().size());
IMetadataRepositoryManager metadataRepositoryManager = getMetadataRepositoryManager();
IMetadataRepository repo1 = null;
IMetadataRepository repo2 = null;
try {
repo1 = metadataRepositoryManager.loadRepository(child1.toURI(), null);
repo2 = metadataRepositoryManager.loadRepository(child2.toURI(), null);
} catch (ProvisionException e) {
fail("Unable to load repositories for verification", e);
}
assertContains("Assert child1's content is in composite repo", repo1, compRepo);
assertContains("Assert child2's content is in composite repo", repo2, compRepo);
//checks that the destination has the correct number of keys (no extras)
assertEquals("Assert correct number of IUs", getNumUnique(repo1.query(QueryUtil.createIUAnyQuery(), null), repo2.query(QueryUtil.createIUAnyQuery(), null)), compRepo.query(QueryUtil.createIUAnyQuery(), null).toUnmodifiableSet().size());
}
public void testRemoveNonexistantChild() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
//Setup, populate the children
File child = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
File invalidChild = getTestData("2", "/testData/mirror/mirrorSourceRepo2");
compRepo.removeChild(invalidChild.toURI());
//Should not affect the size of children
assertEquals("Children size after remove", 1, compRepo.getChildren().size());
}
public void testRemoveAllChildren() {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(false);
assertEquals("Initial Children size", 0, compRepo.getChildren().size());
File child1 = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child1.toURI());
assertEquals("Children size with 1 child", 1, compRepo.getChildren().size());
File child2 = getTestData("2", "/testData/mirror/mirrorSourceRepo2");
compRepo.addChild(child2.toURI());
assertEquals("Children size with 2 children", 2, compRepo.getChildren().size());
compRepo.removeAllChildren();
assertEquals("Children size after removeAllChildren", 0, compRepo.getChildren().size());
}
public void testLoadingRepositoryRemote() {
File knownGoodRepoLocation = getTestData("0.1", "/testData/metadataRepo/composite/good.remote");
CompositeMetadataRepository compRepo = null;
PrintStream out = System.out;
try {
System.setOut(new PrintStream(new StringBufferStream()));
compRepo = (CompositeMetadataRepository) getMetadataRepositoryManager().loadRepository(knownGoodRepoLocation.toURI(), null);
} catch (ProvisionException e) {
fail("0.99", e);
} finally {
System.setOut(out);
}
List children = compRepo.getChildren();
try {
//ensure children are correct
URI child1 = URIUtil.fromString("http://www.eclipse.org/foo");
assertTrue("1.0", children.contains(child1));
URI child2 = URIUtil.fromString("http://www.eclipse.org/bar");
assertTrue("1.1", children.contains(child2));
assertEquals("1.2", 2, children.size());
} catch (URISyntaxException e) {
fail("1.99", e);
}
//ensure correct properties
assertEquals("2.0", "metadata name", compRepo.getName());
Map properties = compRepo.getProperties();
assertEquals("2.1", 2, properties.size());
String timestamp = (String) properties.get(IRepository.PROP_TIMESTAMP);
assertNotNull("2.2", timestamp);
assertEquals("2.3", "1234", timestamp);
String compressed = (String) properties.get(IRepository.PROP_COMPRESSED);
assertNotNull("2.4", compressed);
assertFalse("2.5", Boolean.parseBoolean(compressed));
}
public void testLoadingRepositoryLocal() {
File testData = getTestData("0.5", "/testData/metadataRepo/composite/good.local");
copy("0.6", testData, repoLocation);
CompositeMetadataRepository compRepo = null;
try {
compRepo = (CompositeMetadataRepository) getMetadataRepositoryManager().loadRepository(repoLocation.toURI(), null);
} catch (ProvisionException e) {
fail("0.9", e);
}
List children = compRepo.getChildren();
//ensure children are correct
URI child1 = URIUtil.append(compRepo.getLocation(), "one");
assertTrue("1.0", children.contains(child1));
URI child2 = URIUtil.append(compRepo.getLocation(), "two");
assertTrue("1.1", children.contains(child2));
assertEquals("1.2", 2, children.size());
//ensure correct properties
assertEquals("2.0", "metadata name", compRepo.getName());
Map properties = compRepo.getProperties();
assertEquals("2.1", 2, properties.size());
String timestamp = (String) properties.get(IRepository.PROP_TIMESTAMP);
assertNotNull("2.2", timestamp);
assertEquals("2.3", "1234", timestamp);
String compressed = (String) properties.get(IRepository.PROP_COMPRESSED);
assertNotNull("2.4", compressed);
assertFalse("2.5", Boolean.parseBoolean(compressed));
}
public void testCompressedPersistence() {
persistenceTest(true);
}
public void testUncompressedPersistence() {
persistenceTest(false);
}
public void testSyntaxErrorWhileParsing() {
File badCompositeContent = getTestData("1", "/testData/metadataRepo/composite/Bad/syntaxError");
StringBuffer buffer = new StringBuffer();
PrintStream err = System.err;
try {
System.setErr(new PrintStream(new StringBufferStream(buffer)));
getMetadataRepositoryManager().loadRepository(badCompositeContent.toURI(), null);
//Error while parsing expected
fail("Expected ProvisionException has not been thrown");
} catch (ProvisionException e) {
assertTrue(buffer.toString().contains("The element type \"children\" must be terminated by the matching end-tag \"</children>\"."));
} finally {
System.setErr(err);
}
}
public void testMissingRequireattributeWhileParsing() {
File badCompositeContent = getTestData("0.1", "/testData/metadataRepo/composite/Bad/missingRequiredAttribute");
copy("0.2", badCompositeContent, repoLocation);
CompositeMetadataRepository compRepo = null;
PrintStream out = System.out;
try {
System.setOut(new PrintStream(new StringBufferStream()));
compRepo = (CompositeMetadataRepository) getMetadataRepositoryManager().loadRepository(repoLocation.toURI(), null);
} catch (ProvisionException e) {
fail("1.99", e);
} finally {
System.setOut(out);
}
assertEquals("2.0", 1, compRepo.getChildren().size());
}
public void testEnabledAndSystemValues() {
//Setup make repositories
File repo1Location = getTestFolder(getUniqueString());
File repo2Location = getTestFolder(getUniqueString());
File compRepoLocation = getTestFolder(getUniqueString());
CompositeMetadataRepository compRepo = null;
try {
getMetadataRepositoryManager().createRepository(repo1Location.toURI(), "Repo 1", IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);
getMetadataRepositoryManager().createRepository(repo2Location.toURI(), "Repo 2", IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);
//Only 1 child should be loaded in the manager
getMetadataRepositoryManager().removeRepository(repo2Location.toURI());
compRepo = (CompositeMetadataRepository) getMetadataRepositoryManager().createRepository(compRepoLocation.toURI(), "Composite Repo", IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, null);
} catch (ProvisionException e) {
fail("Error creating repositories", e);
}
compRepo.addChild(repo1Location.toURI());
compRepo.addChild(repo2Location.toURI());
//force composite repository to load all children
compRepo.query(QueryUtil.createIUAnyQuery(), new NullProgressMonitor());
assertTrue("Ensuring previously loaded repo is enabled", getMetadataRepositoryManager().isEnabled(repo1Location.toURI()));
String repo1System = getMetadataRepositoryManager().getRepositoryProperty(repo1Location.toURI(), IRepository.PROP_SYSTEM);
//if repo1System is null we want to fail
assertFalse("Ensuring previously loaded repo is not system", repo1System != null ? repo1System.equals(Boolean.toString(true)) : true);
assertFalse("Ensuring not previously loaded repo is not enabled", getMetadataRepositoryManager().isEnabled(repo2Location.toURI()));
String repo2System = getMetadataRepositoryManager().getRepositoryProperty(repo2Location.toURI(), IRepository.PROP_SYSTEM);
//if repo2System is null we want to fail
assertTrue("Ensuring not previously loaded repo is system", repo2System != null ? repo2System.equals(Boolean.toString(true)) : false);
}
public void testGetLatestIU() {
CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
URI location1;
URI location2;
try {
location1 = TestData.getFile("metadataRepo", "multipleversions1").toURI();
location2 = TestData.getFile("metadataRepo", "multipleversions2").toURI();
} catch (Exception e) {
fail("0.99", e);
return;
}
CompositeMetadataRepository compositeRepo = createRepo(false);
compositeRepo.addChild(location1);
compositeRepo.addChild(location2);
IQueryResult queryResult = compositeRepo.query(QueryUtil.createLatestIUQuery(), monitor);
assertEquals("1.0", 1, queryResultSize(queryResult));
assertEquals("1.1", Version.createOSGi(3, 0, 0), ((IInstallableUnit) queryResult.iterator().next()).getVersion());
assertTrue("1.2", monitor.isDone());
assertTrue("1.3", monitor.isWorkDone());
}
public void testGetLatestIULessThan3() {
CompoundQueryTestProgressMonitor monitor = new CompoundQueryTestProgressMonitor();
URI location1;
URI location2;
try {
location1 = TestData.getFile("metadataRepo", "multipleversions1").toURI();
location2 = TestData.getFile("metadataRepo", "multipleversions2").toURI();
} catch (Exception e) {
fail("0.99", e);
return;
}
CompositeMetadataRepository compositeRepo = createRepo(false);
compositeRepo.addChild(location1);
compositeRepo.addChild(location2);
IQuery cQuery = QueryUtil.createLatestQuery(new MatchQuery() {
public boolean isMatch(Object candidate) {
if (candidate instanceof IInstallableUnit) {
IInstallableUnit iInstallableUnit = (IInstallableUnit) candidate;
if (iInstallableUnit.getVersion().compareTo(Version.createOSGi(3, 0, 0)) < 0)
return true;
}
return false;
}
});
IQueryResult queryResult = compositeRepo.query(cQuery, monitor);
assertEquals("1.0", 1, queryResultSize(queryResult));
assertEquals("1.1", Version.createOSGi(2, 2, 0), ((IInstallableUnit) queryResult.iterator().next()).getVersion());
assertTrue("1.2", monitor.isDone());
assertTrue("1.3", monitor.isWorkDone());
}
private void persistenceTest(boolean compressed) {
//Setup: create an uncompressed repository
CompositeMetadataRepository compRepo = createRepo(compressed);
//Add data. forces write to disk.
File child1 = getTestData("1", "/testData/mirror/mirrorSourceRepo1 with space");
compRepo.addChild(child1.toURI());
File child2 = getTestData("2", "/testData/mirror/mirrorSourceRepo2");
compRepo.addChild(child2.toURI());
//Assume success (covered by other tests)
//Remove repo from memory
IMetadataRepositoryManager metadataRepositoryManager = getMetadataRepositoryManager();
metadataRepositoryManager.removeRepository(repoLocation.toURI());
compRepo = null;
//load repository off disk
IMetadataRepository repo = null;
try {
repo = metadataRepositoryManager.loadRepository(repoLocation.toURI(), null);
} catch (ProvisionException e) {
fail("Could not load repository after removal", e);
}
assertTrue("loaded repository was of type CompositeMetadataRepository", repo instanceof CompositeMetadataRepository);
compRepo = (CompositeMetadataRepository) repo;
IMetadataRepository repo1 = null;
IMetadataRepository repo2 = null;
try {
repo1 = metadataRepositoryManager.loadRepository(child1.toURI(), null);
repo2 = metadataRepositoryManager.loadRepository(child2.toURI(), null);
} catch (ProvisionException e) {
fail("Unable to load repositories for verification", e);
}
assertContains("Assert child1's content is in composite repo", repo1, compRepo);
assertContains("Assert child2's content is in composite repo", repo2, compRepo);
//checks that the destination has the correct number of keys (no extras)
assertEquals("Assert correct number of IUs", getNumUnique(repo1.query(QueryUtil.createIUAnyQuery(), null), repo2.query(QueryUtil.createIUAnyQuery(), null)), compRepo.query(QueryUtil.createIUAnyQuery(), null).toUnmodifiableSet().size());
}
private CompositeMetadataRepository createRepo(boolean compressed) {
IMetadataRepositoryManager metadataRepositoryManager = getMetadataRepositoryManager();
Map properties = new HashMap();
properties.put(IRepository.PROP_COMPRESSED, compressed ? "true" : "false");
IMetadataRepository repo = null;
try {
repo = metadataRepositoryManager.createRepository(repoLocation.toURI(), "metadata name", IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, properties);
} catch (ProvisionException e) {
fail("Could not create repository");
}
//esnure proper type of repository has been created
if (!(repo instanceof CompositeMetadataRepository))
fail("Repository is not a CompositeMetadataRepository");
return (CompositeMetadataRepository) repo;
}
/**
* Takes 2 collectors, compares them, and returns the number of unique keys
* Needed to verify that only the appropriate number of files have been transfered by the mirror application
*/
private int getNumUnique(IQueryResult<IInstallableUnit> c1, IQueryResult<IInstallableUnit> c2) {
Set<IInstallableUnit> set1 = c1.toUnmodifiableSet();
Set<IInstallableUnit> set2 = c2.toUnmodifiableSet();
//initialize to the size of both collectors
int numKeys = set1.size() + set2.size();
for (IInstallableUnit iu1 : set1) {
for (IInstallableUnit iu2 : set2) {
if (isEqual(iu1, iu2))
numKeys--;
//identical keys has bee found, therefore the number of unique keys is one less than previously thought
}
}
return numKeys;
}
/*
* Ensure that we can create a non-local composite repository.
* Note that we had to change this test method when we changed the
* behaviour of the composite repos to aggressively load the children.
*/
public void testNonLocalRepo() {
PrintStream out = System.out;
try {
System.setOut(new PrintStream(new StringBufferStream()));
URI location = new URI("http://foo.org/in/memory");
URI childOne = new URI("http://foo.org/in/memory/one");
URI childTwo = new URI("http://foo.org/in/memory/two");
URI childThree = new URI("http://foo.org/in/memory/three");
CompositeMetadataRepository repository = createRepository(location, "in memory test");
repository.addChild(childOne);
repository.addChild(childTwo);
repository.addChild(childThree);
assertEquals("1.0", 3, repository.getChildren().size());
repository.removeChild(childTwo);
assertEquals("1.1", 2, repository.getChildren().size());
// add a child which already exists... should do nothing
repository.addChild(childOne);
assertEquals("1.2", 2, repository.getChildren().size());
// add the same child but with a relative URI. again it should do nothing
repository.addChild(new URI("one"));
assertEquals("1.3", 2, repository.getChildren().size());
} catch (URISyntaxException e) {
fail("99.0", e);
} finally {
System.setOut(out);
}
}
protected CompositeMetadataRepository createRepository(URI location, String name) {
CompositeMetadataRepositoryFactory factory = new CompositeMetadataRepositoryFactory();
factory.setAgent(getAgent());
return (CompositeMetadataRepository) factory.create(location, name, CompositeMetadataRepository.REPOSITORY_TYPE, null);
}
public void testRelativeChildren() {
// setup
File one = getTestData("0.0", "testData/testRepos/simple.1");
File two = getTestData("0.1", "testData/testRepos/simple.2");
File temp = getTempFolder();
copy("0.2", one, new File(temp, "one"));
copy("0.3", two, new File(temp, "two"));
// create the composite repository and add the children
URI location = new File(temp, "comp").toURI();
CompositeMetadataRepository repository = createRepository(location, "test");
try {
repository.addChild(new URI("../one"));
repository.addChild(new URI("../two"));
} catch (URISyntaxException e) {
fail("1.99", e);
}
// query the number of IUs
List children = repository.getChildren();
assertEquals("2.0", 2, children.size());
IQueryResult queryResult = repository.query(QueryUtil.createIUAnyQuery(), getMonitor());
assertEquals("2.1", 2, queryResultSize(queryResult));
// ensure the child URIs are stored as relative
CompositeRepositoryState state = repository.toState();
URI[] childURIs = state.getChildren();
assertNotNull("3.0", childURIs);
assertEquals("3.1", 2, childURIs.length);
assertFalse("3.2", childURIs[0].isAbsolute());
assertFalse("3.3", childURIs[1].isAbsolute());
// cleanup
delete(temp);
}
public void testRelativeRemoveChild() {
PrintStream out = System.out;
try {
System.setOut(new PrintStream(new StringBufferStream()));
URI location = new URI("http://foo.org/in/memory");
URI one = new URI("one");
URI two = new URI("two");
CompositeMetadataRepository repository = createRepository(location, "in memory test");
repository.addChild(one);
repository.addChild(two);
List children = repository.getChildren();
assertEquals("1.0", 2, children.size());
// remove an absolute URI (child one should be first since order is important)
repository.removeChild((URI) children.iterator().next());
assertEquals("1.1", 1, repository.getChildren().size());
// remove a relative URI (child two)
repository.removeChild(two);
assertEquals("1.2", 0, repository.getChildren().size());
} catch (URISyntaxException e) {
fail("99.0", e);
} finally {
System.setOut(out);
}
}
}