| /******************************************************************************* |
| * Copyright (c) 2009, 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 |
| *******************************************************************************/ |
| package org.eclipse.equinox.p2.tests.publisher.actions; |
| |
| import java.util.*; |
| import junit.framework.TestCase; |
| import org.eclipse.equinox.internal.p2.metadata.InstallableUnit; |
| import org.eclipse.equinox.internal.p2.metadata.RequiredCapability; |
| import org.eclipse.equinox.p2.metadata.*; |
| import org.eclipse.equinox.p2.publisher.eclipse.AdviceFileParser; |
| import org.eclipse.equinox.p2.query.QueryUtil; |
| |
| public class AdviceFileParserTest extends TestCase { |
| public void testNoAdvice() { |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, Collections.EMPTY_MAP); |
| parser.parse(); |
| assertNull(parser.getAdditionalInstallableUnitDescriptions()); |
| assertNull(parser.getProperties()); |
| assertNull(parser.getProvidedCapabilities()); |
| assertNull(parser.getRequiredCapabilities()); |
| assertNull(parser.getTouchpointInstructions()); |
| } |
| |
| public void testAdviceVersion() { |
| Map map = new HashMap(); |
| map.put("advice.version", "1.0"); |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| |
| map.put("advice.version", "999"); |
| parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| try { |
| parser.parse(); |
| } catch (IllegalStateException e) { |
| return; |
| } |
| fail("expected version parse problem"); |
| } |
| |
| public void testUpdateDescriptorAdvice() { |
| Map map = new HashMap(); |
| map.put("update.id", "testName"); |
| map.put("update.severity", "10"); |
| map.put("update.description", "Test Description"); |
| map.put("update.range", "(1.0.0,10.10.10)"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| |
| IUpdateDescriptor updateDescriptor = parser.getUpdateDescriptor(); |
| String testName = RequiredCapability.extractName(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| VersionRange testVersionRange = RequiredCapability.extractRange(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| assertEquals("testName", testName); |
| assertEquals(Version.parseVersion("1.0.0"), testVersionRange.getMinimum()); |
| assertEquals(Version.parseVersion("10.10.10"), testVersionRange.getMaximum()); |
| assertEquals(10, updateDescriptor.getSeverity()); |
| assertEquals("Test Description", updateDescriptor.getDescription()); |
| } |
| |
| public void testUpdateDescriptorAdviceDefaultBound() { |
| Map map = new HashMap(); |
| map.put("update.id", "testName"); |
| map.put("update.severity", "10"); |
| map.put("update.description", "Test Description"); |
| map.put("update.range", "(1.0.0,$version$)"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.parseVersion("9.10.11"), map); |
| parser.parse(); |
| |
| IUpdateDescriptor updateDescriptor = parser.getUpdateDescriptor(); |
| String testName = RequiredCapability.extractName(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| VersionRange testVersionRange = RequiredCapability.extractRange(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| assertEquals("testName", testName); |
| assertEquals(Version.parseVersion("1.0.0"), testVersionRange.getMinimum()); |
| assertEquals(Version.parseVersion("9.10.11"), testVersionRange.getMaximum()); |
| assertEquals(10, updateDescriptor.getSeverity()); |
| assertEquals("Test Description", updateDescriptor.getDescription()); |
| } |
| |
| public void testUpdateDescriptorAdviceDefaultBound2() { |
| Map map = new HashMap(); |
| map.put("update.id", "testName"); |
| map.put("update.severity", "10"); |
| map.put("update.description", "Test Description"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.parseVersion("9.10.11"), map); |
| parser.parse(); |
| |
| IUpdateDescriptor updateDescriptor = parser.getUpdateDescriptor(); |
| String testName = RequiredCapability.extractName(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| VersionRange testVersionRange = RequiredCapability.extractRange(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| assertEquals("testName", testName); |
| assertEquals(Version.parseVersion("0.0.0"), testVersionRange.getMinimum()); |
| assertEquals(Version.parseVersion("9.10.11"), testVersionRange.getMaximum()); |
| assertEquals(10, updateDescriptor.getSeverity()); |
| assertEquals("Test Description", updateDescriptor.getDescription()); |
| } |
| |
| public void testUpdateDescriptorAdviceDefaultID() { |
| Map map = new HashMap(); |
| map.put("update.severity", "10"); |
| map.put("update.description", "Test Description"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.parseVersion("9.10.11"), map); |
| parser.parse(); |
| |
| IUpdateDescriptor updateDescriptor = parser.getUpdateDescriptor(); |
| String testName = RequiredCapability.extractName(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| VersionRange testVersionRange = RequiredCapability.extractRange(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| assertEquals("id", testName); |
| assertEquals(Version.parseVersion("0.0.0"), testVersionRange.getMinimum()); |
| assertEquals(Version.parseVersion("9.10.11"), testVersionRange.getMaximum()); |
| assertEquals(10, updateDescriptor.getSeverity()); |
| assertEquals("Test Description", updateDescriptor.getDescription()); |
| } |
| |
| public void testUpdateDescriptorAdviceDefaults() { |
| Map map = new HashMap(); |
| map.put("update.id", "id"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.parseVersion("9.10.11"), map); |
| parser.parse(); |
| |
| IUpdateDescriptor updateDescriptor = parser.getUpdateDescriptor(); |
| String testName = RequiredCapability.extractName(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| VersionRange testVersionRange = RequiredCapability.extractRange(updateDescriptor.getIUsBeingUpdated().iterator().next()); |
| assertEquals("id", testName); |
| assertEquals(Version.parseVersion("0.0.0"), testVersionRange.getMinimum()); |
| assertEquals(Version.parseVersion("9.10.11"), testVersionRange.getMaximum()); |
| assertEquals(0, updateDescriptor.getSeverity()); |
| assertEquals(null, updateDescriptor.getDescription()); |
| } |
| |
| public void testPropertyAdvice() { |
| Map map = new HashMap(); |
| map.put("properties.0.name", "testName1"); |
| map.put("properties.0.value", "testValue1"); |
| map.put("properties.1.name", "testName2"); |
| map.put("properties.1.value", "testValue2"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| assertEquals("testValue1", parser.getProperties().get("testName1")); |
| assertEquals("testValue2", parser.getProperties().get("testName2")); |
| } |
| |
| public void testProvidesAdvice() { |
| Map map = new HashMap(); |
| map.put("provides.0.namespace", "testNamespace1"); |
| map.put("provides.0.name", "testName1"); |
| map.put("provides.0.version", "1.2.3.$qualifier$"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.create("1.0.0.v20090909"), map); |
| parser.parse(); |
| IProvidedCapability[] capabilities = parser.getProvidedCapabilities(); |
| assertEquals(1, capabilities.length); |
| assertEquals("testNamespace1", capabilities[0].getNamespace()); |
| assertEquals("testName1", capabilities[0].getName()); |
| assertEquals(Version.create("1.2.3.v20090909"), capabilities[0].getVersion()); |
| |
| map.put("provides.1.namespace", "testNamespace2"); |
| map.put("provides.1.name", "testName2"); |
| map.put("provides.1.version", "$version$"); |
| |
| parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| capabilities = parser.getProvidedCapabilities(); |
| assertEquals(2, capabilities.length); |
| assertEquals("testNamespace1", capabilities[0].getNamespace()); |
| assertEquals("testName1", capabilities[0].getName()); |
| assertEquals(Version.create("1.2.3"), capabilities[0].getVersion()); |
| assertEquals("testNamespace2", capabilities[1].getNamespace()); |
| assertEquals("testName2", capabilities[1].getName()); |
| assertEquals(Version.emptyVersion, capabilities[1].getVersion()); |
| } |
| |
| public void testRequiresAdvice() { |
| Map map = new HashMap(); |
| map.put("requires.0.namespace", "testNamespace1"); |
| map.put("requires.0.name", "testName1"); |
| map.put("requires.0.range", "[1.2.3.$qualifier$, 2)"); |
| map.put("requires.0.greedy", Boolean.TRUE.toString()); |
| map.put("requires.0.optional", Boolean.TRUE.toString()); |
| map.put("requires.0.multiple", Boolean.TRUE.toString()); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.create("1.0.0.v20090909"), map); |
| parser.parse(); |
| IRequirement[] reqs = parser.getRequiredCapabilities(); |
| assertEquals(1, reqs.length); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(reqs[0].getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(reqs[0].getMatches())); |
| assertEquals(new VersionRange("[1.2.3.v20090909, 2)"), RequiredCapability.extractRange(reqs[0].getMatches())); |
| |
| map.put("requires.1.namespace", "testNamespace2"); |
| map.put("requires.1.name", "testName2"); |
| map.put("requires.1.range", "$version$"); |
| map.put("requires.1.greedy", Boolean.FALSE.toString()); |
| map.put("requires.1.optional", Boolean.FALSE.toString()); |
| //default |
| // map.put("requires.1.multiple", Boolean.FALSE.toString()); |
| |
| parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| reqs = parser.getRequiredCapabilities(); |
| assertEquals(2, reqs.length); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(reqs[0].getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(reqs[0].getMatches())); |
| assertEquals(new VersionRange("[1.2.3, 2)"), RequiredCapability.extractRange(reqs[0].getMatches())); |
| assertEquals(true, reqs[0].isGreedy()); |
| assertEquals(0, reqs[0].getMin()); |
| assertEquals("testNamespace2", RequiredCapability.extractNamespace(reqs[1].getMatches())); |
| assertEquals("testName2", RequiredCapability.extractName(reqs[1].getMatches())); |
| assertEquals(new VersionRange(Version.emptyVersion.toString()), RequiredCapability.extractRange(reqs[1].getMatches())); |
| assertEquals(false, reqs[1].isGreedy()); |
| assertEquals(1, reqs[1].getMin()); |
| } |
| |
| public void testMetaRequiresAdvice() { |
| Map map = new HashMap(); |
| map.put("metaRequirements.0.namespace", "testNamespace1"); |
| map.put("metaRequirements.0.name", "testName1"); |
| map.put("metaRequirements.0.range", "[1.2.3.$qualifier$, 2)"); |
| map.put("metaRequirements.0.greedy", Boolean.TRUE.toString()); |
| map.put("metaRequirements.0.optional", Boolean.TRUE.toString()); |
| map.put("metaRequirements.0.multiple", Boolean.TRUE.toString()); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.create("1.0.0.v20090909"), map); |
| parser.parse(); |
| IRequirement[] reqs = parser.getMetaRequiredCapabilities(); |
| assertEquals(1, reqs.length); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(reqs[0].getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(reqs[0].getMatches())); |
| assertEquals(new VersionRange("[1.2.3.v20090909, 2)"), RequiredCapability.extractRange(reqs[0].getMatches())); |
| |
| map.put("metaRequirements.1.namespace", "testNamespace2"); |
| map.put("metaRequirements.1.name", "testName2"); |
| map.put("metaRequirements.1.range", "$version$"); |
| map.put("metaRequirements.1.greedy", Boolean.FALSE.toString()); |
| map.put("metaRequirements.1.optional", Boolean.FALSE.toString()); |
| //default |
| // map.put("requires.1.multiple", Boolean.FALSE.toString()); |
| |
| parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| reqs = parser.getMetaRequiredCapabilities(); |
| assertEquals(2, reqs.length); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(reqs[0].getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(reqs[0].getMatches())); |
| assertEquals(new VersionRange("[1.2.3, 2)"), RequiredCapability.extractRange(reqs[0].getMatches())); |
| assertEquals(true, reqs[0].isGreedy()); |
| assertEquals(0, reqs[0].getMin()); |
| assertEquals("testNamespace2", RequiredCapability.extractNamespace(reqs[1].getMatches())); |
| assertEquals("testName2", RequiredCapability.extractName(reqs[1].getMatches())); |
| assertEquals(new VersionRange(Version.emptyVersion.toString()), RequiredCapability.extractRange(reqs[1].getMatches())); |
| assertEquals(false, reqs[1].isGreedy()); |
| assertEquals(1, reqs[1].getMin()); |
| } |
| |
| public void testInstructionsAdvice() { |
| Map map = new HashMap(); |
| map.put("instructions.configure", "addProgramArg(programArg:-startup); addProgramArg(programArg:@artifact);"); |
| |
| map.put("instructions.unconfigure", "removeProgramArg(programArg:-startup); removeProgramArg(programArg:@artifact);)"); |
| map.put("instructions.unconfigure.import", "some.removeProgramArg"); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| ITouchpointInstruction configure = parser.getTouchpointInstructions().get("configure"); |
| assertEquals(null, configure.getImportAttribute()); |
| assertEquals("addProgramArg(programArg:-startup); addProgramArg(programArg:@artifact);", configure.getBody()); |
| |
| ITouchpointInstruction unconfigure = parser.getTouchpointInstructions().get("unconfigure"); |
| assertEquals("some.removeProgramArg", unconfigure.getImportAttribute()); |
| assertEquals("removeProgramArg(programArg:-startup); removeProgramArg(programArg:@artifact);)", unconfigure.getBody()); |
| } |
| |
| public void testAdditionalInstallableUnitDescriptionsAdvice() { |
| Map map = new HashMap(); |
| map.put("units.0.id", "testid0"); |
| map.put("units.0.version", "1.2.3"); |
| |
| map.put("units.1.id", "testid1"); |
| map.put("units.1.version", "1.2.4"); |
| map.put("units.1.singleton", "true"); |
| map.put("units.1.copyright", "testCopyright"); |
| map.put("units.1.copyright.location", "http://localhost/test"); |
| map.put("units.1.filter", "(test=testFilter)"); |
| map.put("units.1.touchpoint.id", "testTouchpointId"); |
| map.put("units.1.touchpoint.version", "1.2.5"); |
| map.put("units.1.update.id", "testid1"); |
| map.put("units.1.update.range", "(1,2)"); |
| map.put("units.1.update.severity", "2"); |
| map.put("units.1.update.description", "some description"); |
| map.put("units.1.artifacts.0.id", "testArtifact1"); |
| map.put("units.1.artifacts.0.version", "1.2.6"); |
| map.put("units.1.artifacts.0.classifier", "testClassifier1"); |
| map.put("units.1.artifacts.1.id", "testArtifact2"); |
| map.put("units.1.artifacts.1.version", "1.2.7"); |
| map.put("units.1.artifacts.1.classifier", "testClassifier2"); |
| map.put("units.1.licenses.0", "testLicense"); |
| map.put("units.1.licenses.0.location", "http://localhost/license"); |
| map.put("units.1.properties.0.name", "testName1"); |
| map.put("units.1.properties.0.value", "testValue1"); |
| map.put("units.1.properties.1.name", "testName2"); |
| map.put("units.1.properties.1.value", "testValue2"); |
| map.put("units.1.requires.0.namespace", "testNamespace1"); |
| map.put("units.1.requires.0.name", "testName1"); |
| map.put("units.1.requires.0.range", "[1.2.3.$qualifier$, 2)"); |
| map.put("units.1.requires.0.greedy", Boolean.TRUE.toString()); |
| map.put("units.1.requires.0.optional", Boolean.TRUE.toString()); |
| map.put("units.1.requires.0.multiple", Boolean.TRUE.toString()); |
| map.put("units.1.requires.1.namespace", "testNamespace2"); |
| map.put("units.1.requires.1.name", "testName2"); |
| map.put("units.1.requires.1.range", "$version$"); |
| map.put("units.1.requires.1.greedy", Boolean.FALSE.toString()); |
| map.put("units.1.requires.1.optional", Boolean.FALSE.toString()); |
| map.put("units.1.metaRequirements.0.namespace", "testNamespace1"); |
| map.put("units.1.metaRequirements.0.name", "testName1"); |
| map.put("units.1.metaRequirements.0.range", "[1.2.3.$qualifier$, 2)"); |
| map.put("units.1.metaRequirements.0.greedy", Boolean.TRUE.toString()); |
| map.put("units.1.metaRequirements.0.optional", Boolean.TRUE.toString()); |
| map.put("units.1.metaRequirements.0.multiple", Boolean.TRUE.toString()); |
| map.put("units.1.metaRequirements.1.namespace", "testNamespace2"); |
| map.put("units.1.metaRequirements.1.name", "testName2"); |
| map.put("units.1.metaRequirements.1.range", "$version$"); |
| map.put("units.1.metaRequirements.1.greedy", Boolean.FALSE.toString()); |
| map.put("units.1.metaRequirements.1.optional", Boolean.FALSE.toString()); |
| map.put("units.1.provides.0.namespace", "testNamespace1"); |
| map.put("units.1.provides.0.name", "testName1"); |
| map.put("units.1.provides.0.version", "1.2.3.$qualifier$"); |
| map.put("units.1.provides.1.namespace", "testNamespace2"); |
| map.put("units.1.provides.1.name", "testName2"); |
| map.put("units.1.provides.1.version", "$version$"); |
| map.put("units.1.instructions.configure", "addProgramArg(programArg:-startup); addProgramArg(programArg:@artifact);"); |
| map.put("units.1.instructions.unconfigure", "removeProgramArg(programArg:-startup); removeProgramArg(programArg:@artifact);)"); |
| map.put("units.1.instructions.unconfigure.import", "some.removeProgramArg"); |
| |
| map.put("units.1.hostRequirements.0.namespace", "testNamespace1"); |
| map.put("units.1.hostRequirements.0.name", "testName1"); |
| map.put("units.1.hostRequirements.0.range", "[1.2.3.$qualifier$, 2)"); |
| map.put("units.1.hostRequirements.0.greedy", Boolean.TRUE.toString()); |
| map.put("units.1.hostRequirements.0.optional", Boolean.TRUE.toString()); |
| map.put("units.1.hostRequirements.0.multiple", Boolean.TRUE.toString()); |
| map.put("units.1.hostRequirements.1.namespace", "testNamespace2"); |
| map.put("units.1.hostRequirements.1.name", "testName2"); |
| map.put("units.1.hostRequirements.1.range", "$version$"); |
| map.put("units.1.hostRequirements.1.greedy", Boolean.FALSE.toString()); |
| map.put("units.1.hostRequirements.1.optional", Boolean.FALSE.toString()); |
| |
| AdviceFileParser parser = new AdviceFileParser("id", Version.emptyVersion, map); |
| parser.parse(); |
| MetadataFactory.InstallableUnitDescription[] descriptions = parser.getAdditionalInstallableUnitDescriptions(); |
| IInstallableUnit iu0 = MetadataFactory.createInstallableUnit(descriptions[0]); |
| assertEquals("testid0", iu0.getId()); |
| assertEquals(Version.create("1.2.3"), iu0.getVersion()); |
| assertFalse(iu0.isSingleton()); |
| assertFalse(QueryUtil.isFragment(iu0)); |
| assertEquals(0, iu0.getArtifacts().size()); |
| assertEquals(null, iu0.getCopyright()); |
| assertEquals(null, iu0.getFilter()); |
| assertEquals(0, iu0.getLicenses().size()); |
| assertEquals(0, iu0.getProperties().size()); |
| assertEquals(0, iu0.getRequirements().size()); |
| assertEquals(0, iu0.getProvidedCapabilities().size()); |
| assertEquals(0, iu0.getMetaRequirements().size()); |
| assertEquals(0, iu0.getTouchpointData().size()); |
| assertEquals(ITouchpointType.NONE, iu0.getTouchpointType()); |
| assertEquals(null, iu0.getUpdateDescriptor()); |
| |
| IInstallableUnit iu1 = MetadataFactory.createInstallableUnit(descriptions[1]); |
| assertEquals("testid1", iu1.getId()); |
| assertEquals(Version.create("1.2.4"), iu1.getVersion()); |
| assertTrue(iu1.isSingleton()); |
| assertEquals(2, iu1.getArtifacts().size()); |
| Iterator it = iu1.getArtifacts().iterator(); |
| IArtifactKey key0 = (IArtifactKey) it.next(); |
| IArtifactKey key1 = (IArtifactKey) it.next(); |
| assertEquals("testArtifact1", key0.getId()); |
| assertEquals(Version.create("1.2.6"), key0.getVersion()); |
| assertEquals("testClassifier1", key0.getClassifier()); |
| assertEquals("testArtifact2", key1.getId()); |
| assertEquals(Version.create("1.2.7"), key1.getVersion()); |
| assertEquals("testClassifier2", key1.getClassifier()); |
| assertEquals("testCopyright", iu1.getCopyright().getBody()); |
| assertEquals("http://localhost/test", iu1.getCopyright().getLocation().toString()); |
| assertEquals(InstallableUnit.parseFilter("(test=testFilter)"), iu1.getFilter()); |
| assertEquals("testLicense", iu1.getLicenses().iterator().next().getBody()); |
| assertEquals("http://localhost/license", iu1.getLicenses().iterator().next().getLocation().toString()); |
| assertEquals("testValue1", iu1.getProperty("testName1")); |
| assertEquals("testValue2", iu1.getProperty("testName2")); |
| |
| Collection<IRequirement> reqs = iu1.getRequirements(); |
| Iterator it2 = reqs.iterator(); |
| IRequirement req0 = (IRequirement) it2.next(); |
| IRequirement req1 = (IRequirement) it2.next(); |
| assertEquals(2, reqs.size()); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(req0.getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(req0.getMatches())); |
| assertEquals(new VersionRange("[1.2.3, 2)"), RequiredCapability.extractRange(req0.getMatches())); |
| assertEquals(true, req0.isGreedy()); |
| assertEquals(0, req0.getMin()); |
| assertEquals("testNamespace2", RequiredCapability.extractNamespace(req1.getMatches())); |
| assertEquals("testName2", RequiredCapability.extractName(req1.getMatches())); |
| assertEquals(new VersionRange(Version.emptyVersion.toString()), RequiredCapability.extractRange(req1.getMatches())); |
| assertEquals(false, req1.isGreedy()); |
| assertEquals(1, req1.getMin()); |
| |
| Collection<IProvidedCapability> provided = iu1.getProvidedCapabilities(); |
| Iterator<IProvidedCapability> it4 = provided.iterator(); |
| IProvidedCapability cap1 = it4.next(); |
| IProvidedCapability cap2 = it4.next(); |
| assertEquals(2, provided.size()); |
| assertEquals("testNamespace1", cap1.getNamespace()); |
| assertEquals("testName1", cap1.getName()); |
| assertEquals(Version.create("1.2.3"), cap1.getVersion()); |
| assertEquals("testNamespace2", cap2.getNamespace()); |
| assertEquals("testName2", cap2.getName()); |
| assertEquals(Version.emptyVersion, cap2.getVersion()); |
| |
| Collection<IRequirement> metarequirements = iu1.getMetaRequirements(); |
| assertEquals(2, metarequirements.size()); |
| Iterator it3 = metarequirements.iterator(); |
| IRequirement metaReq0 = (IRequirement) it3.next(); |
| IRequirement metaReq1 = (IRequirement) it3.next(); |
| |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(metaReq0.getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(metaReq0.getMatches())); |
| assertEquals(new VersionRange("[1.2.3, 2)"), RequiredCapability.extractRange(metaReq0.getMatches())); |
| assertEquals(true, metaReq0.isGreedy()); |
| assertEquals(0, metaReq0.getMin()); |
| assertEquals("testNamespace2", RequiredCapability.extractNamespace(metaReq1.getMatches())); |
| assertEquals("testName2", RequiredCapability.extractName(metaReq1.getMatches())); |
| assertEquals(new VersionRange(Version.emptyVersion.toString()), RequiredCapability.extractRange(metaReq1.getMatches())); |
| assertEquals(false, metaReq1.isGreedy()); |
| assertEquals(1, metaReq1.getMin()); |
| |
| assertEquals(1, iu1.getTouchpointData().size()); |
| ITouchpointInstruction configure = iu1.getTouchpointData().iterator().next().getInstruction("configure"); |
| assertEquals(null, configure.getImportAttribute()); |
| assertEquals("addProgramArg(programArg:-startup); addProgramArg(programArg:@artifact);", configure.getBody()); |
| |
| ITouchpointInstruction unconfigure = iu1.getTouchpointData().iterator().next().getInstruction("unconfigure"); |
| assertEquals("some.removeProgramArg", unconfigure.getImportAttribute()); |
| assertEquals("removeProgramArg(programArg:-startup); removeProgramArg(programArg:@artifact);)", unconfigure.getBody()); |
| |
| assertEquals(MetadataFactory.createTouchpointType("testTouchpointId", Version.create("1.2.5")), iu1.getTouchpointType()); |
| assertEquals("testid1", RequiredCapability.extractName(iu1.getUpdateDescriptor().getIUsBeingUpdated().iterator().next())); |
| assertEquals(new VersionRange("(1,2)"), RequiredCapability.extractRange(iu1.getUpdateDescriptor().getIUsBeingUpdated().iterator().next())); |
| assertEquals(2, iu1.getUpdateDescriptor().getSeverity()); |
| assertEquals("some description", iu1.getUpdateDescriptor().getDescription()); |
| |
| assertTrue(QueryUtil.isFragment(iu1)); |
| Collection<IRequirement> hostRequired = ((IInstallableUnitFragment) iu1).getHost(); |
| assertEquals(2, hostRequired.size()); |
| Iterator<IRequirement> iterator = hostRequired.iterator(); |
| IRequirement requirement = iterator.next(); |
| assertEquals("testNamespace1", RequiredCapability.extractNamespace(requirement.getMatches())); |
| assertEquals("testName1", RequiredCapability.extractName(requirement.getMatches())); |
| assertEquals(new VersionRange("[1.2.3, 2)"), RequiredCapability.extractRange(requirement.getMatches())); |
| assertEquals(true, requirement.isGreedy()); |
| assertEquals(0, requirement.getMin()); |
| |
| IRequirement secondRequirement = iterator.next(); |
| assertEquals("testNamespace2", RequiredCapability.extractNamespace(secondRequirement.getMatches())); |
| assertEquals("testName2", RequiredCapability.extractName(secondRequirement.getMatches())); |
| assertEquals(new VersionRange(Version.emptyVersion.toString()), RequiredCapability.extractRange(secondRequirement.getMatches())); |
| assertEquals(false, secondRequirement.isGreedy()); |
| assertEquals(1, secondRequirement.getMin()); |
| } |
| } |
