/*******************************************************************************
* Copyright (c) 2012, 2015 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.osgi.tests.resource;
import java.util.*;
import java.util.Map.Entry;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.junit.Assert;
import org.osgi.framework.Bundle;
import org.osgi.framework.Version;
import org.osgi.framework.namespace.IdentityNamespace;
import org.osgi.framework.wiring.*;
import org.osgi.resource.*;
public class BasicTest extends AbstractResourceTest {
private interface CapabilityProvider {
List getCapabilities(String namespace);
}
static class BasicCapability implements Capability {
private final Map attributes;
private final Map directives;
private final String namespace;
public BasicCapability(String namespace) {
this(namespace, Collections.EMPTY_MAP);
}
public BasicCapability(String namespace, Map attributes) {
this(namespace, attributes, Collections.EMPTY_MAP);
}
public BasicCapability(String namespace, Map attributes, Map directives) {
this.namespace = namespace;
this.attributes = attributes;
this.directives = directives;
}
public String getNamespace() {
return namespace;
}
public Map getDirectives() {
return directives;
}
public Map getAttributes() {
return attributes;
}
public Resource getResource() {
return null;
}
}
private Bundle tb1;
private Bundle tb2;
private Bundle tb3;
private Bundle tb4;
private Bundle tf1;
private Bundle tf2;
public static Test suite() {
return new TestSuite(BasicTest.class);
}
public BasicTest(String name) {
super(name);
}
public void testRequirementMatches() throws Exception {
Bundle tb5 = installer.installBundle("resource.tb5");
Resource requirer = tb5.adapt(BundleRevision.class);
Capability capability1 = createCapability1();
List requirements = requirer.getRequirements(capability1.getNamespace());
assertRequirements(requirements, 3);
Requirement requirement1 = (Requirement) requirements.get(0);
// Match requirement with just a namespace (no filter, attributes, or directives).
assertRequirementMatches(requirement1, capability1);
Capability capability2 = createCapability2();
// Different namespaces should not match.
assertNotRequirementMatches(requirement1, capability2);
Requirement requirement2 = (Requirement) requirements.get(1);
// Make sure the expected attributes are present.
assertAttribute(requirement2, "b", "a");
// Match requirement with namespace and attributes. Requirement attributes have no impact on matching.
assertRequirementMatches(requirement2, capability1);
Requirement requirement3 = (Requirement) requirements.get(2);
assertAttribute(requirement3, "b", "a");
assertAttribute(requirement3, "bar", "foo");
assertFilterDirective(requirement3);
// Match requirement with namespace, attributes, and filter (no other directives).
assertRequirementMatches(requirement3, capability1);
Requirement requirement4 = (Requirement) requirements.get(3);
assertAttribute(requirement4, "a", "b");
assertFilterDirective(requirement4);
// Filters should not match.
assertNotRequirementMatches(requirement4, capability1);
requirements = requirer.getRequirements(capability2.getNamespace());
assertRequirements(requirements, 0);
Requirement requirement5 = (Requirement) requirements.get(0);
assertAttribute(requirement5, "bar", "foo");
assertAttribute(requirement5, "y", "x");
assertFilterDirective(requirement5);
assertDirective(requirement5, "mandatory", "foo,x");
// Mandatory directive should have no impact on generic capabilities or requirements.
assertRequirementMatches(requirement5, capability2);
}
public void testIdentity() throws Exception {
tb1 = installer.installBundle("resource.tb1");
tb2 = installer.installBundle("resource.tb2");
tb3 = installer.installBundle("resource.tb3");
tb4 = installer.installBundle("resource.tb4");
tf1 = installer.installBundle("resource.tf1");
tf2 = installer.installBundle("resource.tf2");
installer.resolveBundles(null);
tb1.start();
tb2.start();
tb3.start();
tb4.start();
assertEquals("tf1 not resolved", tf1.getState(), Bundle.RESOLVED);
assertEquals("tf2 not resolved", tf2.getState(), Bundle.RESOLVED);
assertTb1();
assertTb2();
assertTb3();
assertTb4();
assertTf1();
assertTf2();
}
/*
* TB1
* Requirements:
* None
* Capabilities:
* osgi.identity;osgi.identity=resource.tb1;version=1.0.0;type=osgi.bundle
* osgi.wiring.host;osgi.wiring.host=resource.tb1;version=1.0.0
* Wires:
* osgi.identity <-> TB3
* osgi.wiring.host <-> TF1
* TB4 <-> osgi.identity (via TF1)
*/
private void assertTb1() {
// Get the revision for TB1.
BundleRevision revision = tb1.adapt(BundleRevision.class);
// Make sure TB1's symbolic name and version match the manifest.
String symbolicName = revision.getSymbolicName();
assertSymbolicName("resource.tb1", symbolicName);
Version version = revision.getVersion();
assertVersion("1.0.0", version);
// Make sure TB1's type is correct.
String type = getType(revision);
assertType(IdentityNamespace.TYPE_BUNDLE, type);
Map arbitraryAttrs = new HashMap();
arbitraryAttrs.put("attr1", "a1");
arbitraryAttrs.put("attr2", "a2");
Map arbitraryDirs = new HashMap();
arbitraryDirs.put("dir1", "d1");
arbitraryDirs.put("dir2", "d2");
// Check TB1's osgi.identity capability from the revision.
Capability capability = getIdentityCapability(revision);
assertIdentityCapability(capability, symbolicName, version, type, arbitraryAttrs, arbitraryDirs);
// Check TB1's osgi.identity capability from the resource.
Resource resource = revision;
capability = getIdentityCapability(resource);
assertIdentityCapability(capability, symbolicName, version, type, arbitraryAttrs, arbitraryDirs);
// Check TB1's osgi.identity capability from the wiring.
BundleWiring wiring = tb1.adapt(BundleWiring.class);
capability = getIdentityCapability(wiring);
assertIdentityCapability(capability, symbolicName, version, type, arbitraryAttrs, arbitraryDirs);
// There should be 1 provided osgi.identity wire (TB1 -> TB3).
List wires = wiring.getProvidedWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 1);
// Check the osgi.identity wire between TB1 and TB3.
Wire wire = (Wire) wires.get(0);
BundleRevision requirer = tb3.adapt(BundleRevision.class);
Requirement requirement = getIdentityRequirement(requirer, 1);
assertIdentityWire(wire, capability, revision, requirement, requirer);
// There should be 1 required osgi.identity wire (TB4 -> TB1 via TF1).
wires = wiring.getRequiredWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 1);
// Check the osgi.identity wire between TB4 and TB1 (via TF1).
wire = (Wire) wires.get(0);
BundleRevision provider = tb4.adapt(BundleRevision.class);
capability = getIdentityCapability(provider);
requirement = getIdentityRequirement(tf1.adapt(BundleRevision.class), 0);
assertIdentityWire(wire, capability, provider, requirement, revision);
}
/*
* TB2
* Requirements:
* None
* Capabilities:
* None
* Wires:
* None
*/
private void assertTb2() {
final BundleRevision revision = tb2.adapt(BundleRevision.class);
assertNotIdentityCapability(new CapabilityProvider() {
public List getCapabilities(String namespace) {
return revision.getDeclaredCapabilities(namespace);
}
});
final Resource resource = revision;
assertNotIdentityCapability(new CapabilityProvider() {
public List getCapabilities(String namespace) {
return resource.getCapabilities(namespace);
}
});
final BundleWiring wiring = tb2.adapt(BundleWiring.class);
assertNotIdentityCapability(new CapabilityProvider() {
public List getCapabilities(String namespace) {
return wiring.getCapabilities(namespace);
}
});
}
/*
* TB3
* Requirements:
* osgi.identity;osgi.identity=resource.tb1;version=1.0.0;type=osgi.bundle
* osgi.identity;osgi.identity=resource.tf1;version=1.0.0;type=osgi.fragment
* Capabilities:
* osgi.identity;osgi.identity=resource.tb3;version=1.0.0;type=osgi.bundle
* osgi.wiring.host;osgi.wiring.host=resource.tb3;version=1.0.0
* Wires:
* TB1 <-> osgi.identity
* TF1 <-> osgi.identity
*/
private void assertTb3() {
// Get the revision for TB3.
BundleRevision revision = tb3.adapt(BundleRevision.class);
// Make sure TB3's symbolic name and version match the manifest.
String symbolicName = revision.getSymbolicName();
assertSymbolicName("resource.tb3", symbolicName);
Version version = revision.getVersion();
assertVersion("1.0.0", version);
// Make sure TB3's type is correct.
String type = getType(revision);
assertType(IdentityNamespace.TYPE_BUNDLE, type);
// Check TB3's osgi.identity capability from the revision.
Capability capability = getIdentityCapability(revision);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
Resource resource = revision;
// Check TB3's osgi.identity capability from the resource.
capability = getIdentityCapability(resource);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// Check TB3's osgi.identity capability from the wiring.
BundleWiring wiring = tb3.adapt(BundleWiring.class);
capability = getIdentityCapability(wiring);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// There should be 2 required osgi.identity wires (TB1 -> TB3 and TF1 -> TB3).
List wires = wiring.getRequiredWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 2);
// Check the osgi.identity wire between TB1 and TB3.
Wire wire = (Wire) wires.get(1);
Requirement requirement = getIdentityRequirement(revision, 1);
BundleRevision provider = tb1.adapt(BundleRevision.class);
capability = getIdentityCapability(provider);
assertIdentityWire(wire, capability, provider, requirement, revision);
// Check the osgi.identity wire between TF1 and TB3.
wire = (Wire) wires.get(0);
requirement = getIdentityRequirement(revision, 0);
provider = tf1.adapt(BundleRevision.class);
capability = getIdentityCapability(provider);
assertIdentityWire(wire, capability, provider, requirement, revision);
}
/*
* TB4
* Requirements:
* None
* Capabilities:
* osgi.identity;osgi.identity=resource.tb4;version=1.0.0;type=osgi.bundle
* osgi.wiring.host;osgi.wiring.host=resource.tb4;version=1.0.0
* Wires:
* osgi.identity <-> TB1 (via TF1)
*/
private void assertTb4() {
// Get the revision for TB4.
BundleRevision revision = tb4.adapt(BundleRevision.class);
// Make sure TB4's symbolic name and version match the manifest.
String symbolicName = revision.getSymbolicName();
assertSymbolicName("resource.tb4", symbolicName);
Version version = revision.getVersion();
assertVersion("1.0.0", version);
// Make sure TB4's type is correct.
String type = getType(revision);
assertType(IdentityNamespace.TYPE_BUNDLE, type);
// Check TB4's osgi.identity capability from the revision.
Capability capability = getIdentityCapability(revision);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
Resource resource = revision;
// Check TB4's osgi.identity capability from the resource.
capability = getIdentityCapability(resource);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
BundleWiring wiring = tb4.adapt(BundleWiring.class);
// Check TB4's osgi.identity capability from the wiring.
capability = getIdentityCapability(wiring);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// There should be 1 provided osgi.identity wire (TB4 -> TB1 via TF1).
List wires = wiring.getProvidedWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 1);
// Check the osgi.identity wire between TB4 and TB1 (via TF1).
Wire wire = (Wire) wires.get(0);
// The requirer will be TB1's revision since fragment requirements are merged into the host...
BundleRevision requirer = tb1.adapt(BundleRevision.class);
// ...but the requirement will come from the fragment.
Requirement requirement = getIdentityRequirement(tf1.adapt(BundleRevision.class), 0);
assertIdentityWire(wire, capability, revision, requirement, requirer);
}
/*
* TF1
* Requirements:
* osgi.wiring.host;osgi.wiring.host=resource.tb1;version=1.0.0
* osgi.identity;osgi.identity=resource.tb4;version=1.0.0;type=osgi.bundle
* Capabilities:
* osgi.identity;osgi.identity=resource.tf1;version=1.0.0;type=osgi.fragment
* Wires:
* TB1 <-> osgi.wiring.host
* osgi.identity <-> TB3
*/
private void assertTf1() {
// Get the revision for TF1.
BundleRevision revision = tf1.adapt(BundleRevision.class);
// Make sure TF1's symbolic name and version match the manifest.
String symbolicName = revision.getSymbolicName();
assertSymbolicName("resource.tf1", symbolicName);
Version version = revision.getVersion();
assertVersion("1.0.0", version);
// Make sure TF1's type is correct.
String type = getType(revision);
assertType(IdentityNamespace.TYPE_FRAGMENT, type);
// Check TF1's osgi.identity capability from the revision.
Capability capability = getIdentityCapability(revision);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// Check TF1's osgi.identity capability from the resource.
Resource resource = revision;
capability = getIdentityCapability(resource);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// Check TF1's osgi.identity capability from the wiring.
BundleWiring wiring = tf1.adapt(BundleWiring.class);
capability = getIdentityCapability(wiring);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// There should be 1 provided osgi.identity wire (TF1 -> TB3).
List wires = wiring.getProvidedWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 1);
// Check the osgi.identity wire between TF1 and TB3.
Wire wire = (Wire) wires.get(0);
BundleRevision requirer = tb3.adapt(BundleRevision.class);
Requirement requirement = getIdentityRequirement(requirer, 0);
assertIdentityWire(wire, capability, revision, requirement, requirer);
}
/*
* TF2
* Requirements:
* osgi.wiring.host;osgi.wiring.host=resource.tb1;version=1.0.0
* Capabilities:
* osgi.identity;osgi.identity=resource.tf2;version=1.0.0;type=osgi.fragment
* Wires:
* TB1 <-> osgi.wiring.host
*/
private void assertTf2() {
// Get the revision for TF2.
BundleRevision revision = tf2.adapt(BundleRevision.class);
// Make sure TF1's symbolic name and version match the manifest.
String symbolicName = revision.getSymbolicName();
assertSymbolicName("resource.tf2", symbolicName);
Version version = revision.getVersion();
assertVersion("0.0.0", version);
// Make sure TF1's type is correct.
String type = getType(revision);
assertType(IdentityNamespace.TYPE_FRAGMENT, type);
// Check TF1's osgi.identity capability from the revision.
Capability capability = getIdentityCapability(revision);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// Check TF1's osgi.identity capability from the resource.
Resource resource = revision;
capability = getIdentityCapability(resource);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// Check TF1's osgi.identity capability from the wiring.
BundleWiring wiring = tf2.adapt(BundleWiring.class);
capability = getIdentityCapability(wiring);
assertIdentityCapability(capability, symbolicName, version, type, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
// There should be 0 provided osgi.identity wire (TF1 -> TB3).
List wires = wiring.getProvidedWires(IdentityNamespace.IDENTITY_NAMESPACE);
assertWires(wires, 0);
}
private void assertAttribute(Requirement requirement, String name, Object expected) {
assertEquals("Wrong attribute: " + name, expected, requirement.getAttributes().get(name));
}
private void assertCapabilities(List capabilities, int size) {
assertNotNull("Null capabilities", capabilities);
assertEquals("Wrong number of capabilities", size, capabilities.size());
}
private void assertDirective(Requirement requirement, String name, String expected) {
assertEquals("Wrong directive", expected, requirement.getDirectives().get(name));
}
private void assertFilterDirective(Requirement requirement) {
assertNotNull("Missing filter directive", requirement.getDirectives().get(Namespace.REQUIREMENT_FILTER_DIRECTIVE));
}
private void assertIdentityCapability(Capability capability, String symbolicName, Version version, String type, Map arbitraryAttrs, Map arbitraryDirs) {
assertEquals("Wrong namespace", IdentityNamespace.IDENTITY_NAMESPACE, capability.getNamespace());
assertEquals("Wrong number of attributes", 3 + arbitraryAttrs.size(), capability.getAttributes().size());
// The osgi.identity attribute contains the symbolic name of the resource.
assertSymbolicName(symbolicName, (String) capability.getAttributes().get(IdentityNamespace.IDENTITY_NAMESPACE));
// The version attribute must be of type Version.
// The version attribute contains the version of the resource.
assertVersion(version, (Version) capability.getAttributes().get(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE));
// The type attribute must be of type String.
// The type attribute contains the resource type.
assertType(type, (String) capability.getAttributes().get(IdentityNamespace.CAPABILITY_TYPE_ATTRIBUTE));
Map attributes = capability.getAttributes();
for (Iterator iEntries = arbitraryAttrs.entrySet().iterator(); iEntries.hasNext();) {
Map.Entry entry = (Entry) iEntries.next();
assertEquals("Wrong attribute: " + entry.getKey(), entry.getValue(), attributes.get(entry.getKey()));
}
Map directives = capability.getDirectives();
for (Iterator iEntries = arbitraryDirs.entrySet().iterator(); iEntries.hasNext();) {
Map.Entry entry = (Entry) iEntries.next();
assertEquals("Wrong directive: " + entry.getKey(), entry.getValue(), directives.get(entry.getKey()));
}
}
private void assertIdentityWire(Wire wire, Capability capability, Resource provider, Requirement requirement, Resource requirer) {
assertEquals("Wrong capability", capability, wire.getCapability());
assertEquals("Wrong provider", provider, wire.getProvider());
assertEquals("Wrong requirement", requirement, wire.getRequirement());
assertEquals("Wrong requirer", requirer, wire.getRequirer());
assertRequirementMatches(requirement, capability);
}
private void assertNotIdentityCapability(CapabilityProvider provider) {
List capabilities = provider.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE);
// A resource with no symbolic name must not provide an identity capability.
assertCapabilities(capabilities, 0);
}
private void assertNotRequirementMatches(Requirement requirement, Capability capability) {
if (!(requirement instanceof BundleRequirement) || !(capability instanceof BundleCapability))
return;
assertFalse("Requirement matches capability", ((BundleRequirement) requirement).matches((BundleCapability) capability));
}
private void assertNotNull(Capability capability) {
Assert.assertNotNull("Null capability", capability);
}
private void assertNotNull(Requirement requirement) {
Assert.assertNotNull("Null requirement", requirement);
}
private void assertRequirementMatches(Requirement requirement, Capability capability) {
if (!(requirement instanceof BundleRequirement) || !(capability instanceof BundleCapability))
return;
assertTrue("Requirement does not match capability", ((BundleRequirement) requirement).matches((BundleCapability) capability));
}
private void assertRequirements(List requirements, int index) {
assertNotNull("Null requirements", requirements);
assertTrue("Wrong number of requirements", requirements.size() > index);
}
private void assertSymbolicName(String expected, String actual) {
assertEquals("Wrong symbolic name", expected, actual);
}
private void assertType(String expected, String actual) {
assertEquals("Wrong type", expected, actual);
}
private void assertVersion(String expected, Version actual) {
assertVersion(Version.parseVersion(expected), actual);
}
private void assertVersion(Version expected, Version actual) {
assertEquals("Wrong version", expected, actual);
}
private void assertWires(List wires, int size) {
assertNotNull("Null wires", wires);
assertEquals("Wrong number of wires", size, wires.size());
}
private Capability createCapability1() {
String namespace = "capability.1";
Map attributes = new HashMap();
attributes.put("a", "b");
return new BasicCapability(namespace, attributes);
}
private Capability createCapability2() {
String namespace = "capability.2";
Map attributes = new HashMap();
attributes.put("foo", "bar");
attributes.put("x", "y");
Map directives = new HashMap();
directives.put(Namespace.RESOLUTION_MANDATORY, "foo,x");
return new BasicCapability(namespace, attributes, directives);
}
private Capability getIdentityCapability(BundleRevision revision) {
List capabilities = revision.getDeclaredCapabilities(IdentityNamespace.IDENTITY_NAMESPACE);
assertCapabilities(capabilities, 1);
Capability capability = (Capability) capabilities.get(0);
assertNotNull(capability);
return capability;
}
private Capability getIdentityCapability(BundleWiring wiring) {
List capabilities = wiring.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE);
assertCapabilities(capabilities, 1);
Capability capability = (Capability) capabilities.get(0);
assertNotNull(capability);
return capability;
}
private Capability getIdentityCapability(Resource resource) {
List capabilities = resource.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE);
assertCapabilities(capabilities, 1);
Capability capability = (Capability) capabilities.get(0);
assertNotNull(capability);
return capability;
}
private Requirement getIdentityRequirement(BundleRevision revision, int index) {
List requirements = revision.getDeclaredRequirements(IdentityNamespace.IDENTITY_NAMESPACE);
assertRequirements(requirements, index);
Requirement requirement = (Requirement) requirements.get(index);
assertNotNull(requirement);
return requirement;
}
private String getType(BundleRevision revision) {
return (revision.getTypes() & BundleRevision.TYPE_FRAGMENT) == 0 ? IdentityNamespace.TYPE_BUNDLE : IdentityNamespace.TYPE_FRAGMENT;
}
}