Examples with ResourceImpl org.apache.felix.resolver.test.util.ResourceImpl used on opensource projects

Example 6 with ResourceImpl

use of org.apache.felix.resolver.test.util.ResourceImpl in project felix by apache.

the class ResolverTest method populateScenario9.

private static List<Resource> populateScenario9(Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap) {
    ResourceImpl c1 = new ResourceImpl("C1");
    Capability c1_pkgCap = addCap(c1, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.c");
    ResourceImpl c2 = new ResourceImpl("C2");
    Capability c2_pkgCap = addCap(c2, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.c");
    ResourceImpl a1 = new ResourceImpl("A");
    Capability a1_hostCap = addCap(a1, HostNamespace.HOST_NAMESPACE, "A");
    ResourceImpl f1 = new ResourceImpl("F1", IdentityNamespace.TYPE_FRAGMENT, Version.emptyVersion);
    Requirement f1_hostReq = addReq(f1, HostNamespace.HOST_NAMESPACE, "A");
    Requirement f1_pkgReq = addReq(f1, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.c");
    Capability f1_pkgCap = addCap(f1, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.a", "org.foo.c");
    ResourceImpl b1 = new ResourceImpl("B");
    Requirement b_pkgReq1 = addReq(b1, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.a");
    Requirement b_pkgReq2 = addReq(b1, PackageNamespace.PACKAGE_NAMESPACE, "org.foo.c");
    candMap.put(b_pkgReq1, Collections.singletonList(f1_pkgCap));
    candMap.put(b_pkgReq2, Arrays.asList(c2_pkgCap, c1_pkgCap));
    Map<Resource, List<Wire>> wires = new HashMap<Resource, List<Wire>>();
    wires.put(c1, new ArrayList<Wire>());
    wires.put(c2, new ArrayList<Wire>());
    wires.put(a1, new ArrayList<Wire>());
    wires.put(f1, new ArrayList<Wire>());
    wires.get(f1).add(new SimpleWire(f1_hostReq, a1_hostCap));
    wires.get(a1).add(new SimpleWire(f1_pkgReq, c1_pkgCap, a1, c1));
    Map<Resource, List<Wire>> invertedWires = new HashMap<Resource, List<Wire>>();
    invertedWires.put(c1, new ArrayList<Wire>());
    invertedWires.put(c2, new ArrayList<Wire>());
    invertedWires.put(a1, new ArrayList<Wire>());
    invertedWires.put(f1, new ArrayList<Wire>());
    invertedWires.get(a1).add(new SimpleWire(f1_hostReq, a1_hostCap));
    invertedWires.get(c1).add(new SimpleWire(f1_pkgReq, c1_pkgCap, a1, c1));
    wirings.put(a1, new SimpleWiring(a1, Arrays.asList(a1_hostCap, f1_pkgCap), wires, invertedWires));
    wirings.put(f1, new SimpleWiring(f1, Collections.<Capability>emptyList(), wires, invertedWires));
    wirings.put(c1, new SimpleWiring(c1, Collections.singletonList(c1_pkgCap), wires, invertedWires));
    wirings.put(c2, new SimpleWiring(c2, Collections.singletonList(c2_pkgCap), wires, invertedWires));
    return Collections.<Resource>singletonList(b1);
}

Example 7 with ResourceImpl

use of org.apache.felix.resolver.test.util.ResourceImpl in project felix by apache.

the class ResolverTest method populateScenario17.

private ResolveContext populateScenario17(boolean realSubstitute, boolean felixResolveContext, boolean existingWirings) {
    Map<Requirement, List<Capability>> candMap = new HashMap<Requirement, List<Capability>>();
    ResourceImpl core = new ResourceImpl("core");
    Capability core_pkgCap = addCap(core, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    Capability core_bundleCap = addCap(core, BundleNamespace.BUNDLE_NAMESPACE, "core");
    Requirement core_pkgReq = addReq(core, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    ResourceImpl misc = new ResourceImpl("misc");
    Capability misc_pkgCap = addCap(misc, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    Capability misc_bundleCap = addCap(misc, BundleNamespace.BUNDLE_NAMESPACE, "misc");
    Requirement misc_bundleReq = addReq(misc, BundleNamespace.BUNDLE_NAMESPACE, "core");
    ResourceImpl importsCore = new ResourceImpl("importsCore");
    Capability importsCore_pkgCap = addCap(importsCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg2", "pkg1");
    Requirement importsCore_pkgReq = addReq(importsCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    ResourceImpl requiresMisc = new ResourceImpl("requiresMisc");
    Requirement requiresMisc_pkgReq = addReq(requiresMisc, PackageNamespace.PACKAGE_NAMESPACE, "pkg2");
    Requirement requiresMisc_bundleReq = addReq(requiresMisc, BundleNamespace.BUNDLE_NAMESPACE, "misc");
    ResourceImpl substitutesCore = new ResourceImpl("substitutesCore");
    Capability substitutesCore_pkgCap = addCap(substitutesCore, PackageNamespace.PACKAGE_NAMESPACE, "pkg1");
    candMap.put(core_pkgReq, Collections.singletonList(realSubstitute ? substitutesCore_pkgCap : core_pkgCap));
    candMap.put(misc_bundleReq, Collections.singletonList(core_bundleCap));
    candMap.put(importsCore_pkgReq, Collections.singletonList(realSubstitute ? substitutesCore_pkgCap : core_pkgCap));
    candMap.put(requiresMisc_pkgReq, Collections.singletonList(importsCore_pkgCap));
    candMap.put(requiresMisc_bundleReq, Collections.singletonList(misc_bundleCap));
    Map<Resource, List<Wire>> wires = new HashMap<Resource, List<Wire>>();
    wires.put(substitutesCore, new ArrayList<Wire>());
    wires.put(core, new ArrayList<Wire>());
    if (realSubstitute) {
        wires.get(core).add(new SimpleWire(core_pkgReq, substitutesCore_pkgCap));
    }
    wires.put(misc, new ArrayList<Wire>());
    wires.get(misc).add(new SimpleWire(misc_bundleReq, core_bundleCap));
    Wiring coreWiring = null;
    Map<Resource, Wiring> wirings = new HashMap<Resource, Wiring>();
    if (existingWirings) {
        Map<Resource, List<Wire>> invertedWires = new HashMap<Resource, List<Wire>>();
        invertedWires.put(substitutesCore, new ArrayList<Wire>());
        if (realSubstitute) {
            invertedWires.get(substitutesCore).add(new SimpleWire(core_pkgReq, substitutesCore_pkgCap));
        }
        invertedWires.put(core, new ArrayList<Wire>());
        invertedWires.get(core).add(new SimpleWire(misc_bundleReq, core_bundleCap));
        invertedWires.put(misc, new ArrayList<Wire>());
        wirings.put(substitutesCore, new SimpleWiring(substitutesCore, Arrays.asList(substitutesCore_pkgCap), wires, invertedWires));
        coreWiring = new SimpleWiring(core, Arrays.asList(core_bundleCap, core_pkgCap), wires, invertedWires);
        wirings.put(core, coreWiring);
        wirings.put(misc, new SimpleWiring(misc, Arrays.asList(misc_bundleCap, misc_pkgCap), wires, invertedWires));
    }
    Collection<Resource> mandatory = Collections.<Resource>singletonList(requiresMisc);
    if (felixResolveContext) {
        Map<Wiring, Collection<Wire>> substitutions = new HashMap<Wiring, Collection<Wire>>();
        if (realSubstitute && coreWiring != null) {
            substitutions.put(coreWiring, Arrays.<Wire>asList(new SimpleWire(core_pkgReq, substitutesCore_pkgCap)));
        }
        return new ResolveContextImpl.FelixResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList(), substitutions);
    } else {
        return new ResolveContextImpl(wirings, candMap, mandatory, Collections.<Resource>emptyList());
    }
}

Example 8 with ResourceImpl

use of org.apache.felix.resolver.test.util.ResourceImpl in project felix by apache.

the class ResolverTest method populateScenario8.

private static List<Resource> populateScenario8(Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap) {
    ResourceImpl res2 = new ResourceImpl("res2");
    Requirement req25 = addReq(res2, IdentityNamespace.IDENTITY_NAMESPACE, "res5");
    Requirement req24 = addReq(res2, IdentityNamespace.IDENTITY_NAMESPACE, "res4");
    Requirement req23 = addReq(res2, IdentityNamespace.IDENTITY_NAMESPACE, "res3", true);
    ResourceImpl res3 = new ResourceImpl("res3");
    Requirement req32 = addReq(res3, IdentityNamespace.IDENTITY_NAMESPACE, "res2");
    Requirement req3x = addReq(res3, "foo", "bar");
    ResourceImpl res4 = new ResourceImpl("res4");
    Requirement req45 = addReq(res4, IdentityNamespace.IDENTITY_NAMESPACE, "res5");
    ResourceImpl res5 = new ResourceImpl("res5");
    Requirement req5x1 = addReq(res5, BundleNamespace.BUNDLE_NAMESPACE, "package1", true);
    Requirement req5x2 = addReq(res5, BundleNamespace.BUNDLE_NAMESPACE, "package2", true);
    ResourceImpl res6 = new ResourceImpl("res6");
    Capability cap6x1 = addCap(res6, BundleNamespace.BUNDLE_NAMESPACE, "package1");
    Capability cap6x2 = addCap(res6, BundleNamespace.BUNDLE_NAMESPACE, "package2");
    Requirement req63 = addReq(res6, IdentityNamespace.IDENTITY_NAMESPACE, "res3");
    candMap.put(req25, res5.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req24, res4.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req23, res3.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req32, res2.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req45, res5.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req63, res3.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
    candMap.put(req3x, Arrays.<Capability>asList());
    candMap.put(req5x1, Arrays.<Capability>asList(cap6x1));
    candMap.put(req5x2, Arrays.<Capability>asList(cap6x2));
    return Arrays.<Resource>asList(res2);
}

Example 9 with ResourceImpl

use of org.apache.felix.resolver.test.util.ResourceImpl in project felix by apache.

the class ResolverTest method populateScenario6.

private static List<Resource> populateScenario6(Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap) {
    ResourceImpl a1 = new ResourceImpl("A");
    a1.addRequirement(new PackageRequirement(a1, "p1"));
    a1.addRequirement(new PackageRequirement(a1, "p2"));
    Requirement a1Req = new GenericRequirement(a1, "generic");
    a1Req.getDirectives().put(Namespace.REQUIREMENT_CARDINALITY_DIRECTIVE, Namespace.CARDINALITY_MULTIPLE);
    a1.addRequirement(a1Req);
    ResourceImpl a2 = new ResourceImpl("A");
    a2.addRequirement(new BundleRequirement(a2, "B"));
    a2.addRequirement(new BundleRequirement(a2, "C"));
    Requirement a2Req = new GenericRequirement(a2, "generic");
    a2Req.getDirectives().put(Namespace.REQUIREMENT_CARDINALITY_DIRECTIVE, Namespace.CARDINALITY_MULTIPLE);
    a2.addRequirement(a2Req);
    ResourceImpl b1 = new ResourceImpl("B");
    b1.addCapability(new BundleCapability(b1, "B"));
    Capability b1_p2 = new PackageCapability(b1, "p2");
    b1_p2.getDirectives().put(Namespace.CAPABILITY_USES_DIRECTIVE, "p1");
    b1.addCapability(b1_p2);
    b1.addRequirement(new PackageRequirement(b1, "p1"));
    ResourceImpl b2 = new ResourceImpl("B");
    b2.addCapability(new BundleCapability(b2, "B"));
    Capability b2_p2 = new PackageCapability(b2, "p2");
    b2_p2.getDirectives().put(Namespace.CAPABILITY_USES_DIRECTIVE, "p1");
    b2.addCapability(b2_p2);
    b2.addRequirement(new PackageRequirement(b2, "p1"));
    ResourceImpl c1 = new ResourceImpl("C");
    c1.addCapability(new BundleCapability(c1, "C"));
    Capability c1_p1 = new PackageCapability(c1, "p1");
    c1.addCapability(c1_p1);
    ResourceImpl c2 = new ResourceImpl("C");
    c2.addCapability(new BundleCapability(c2, "C"));
    Capability c2_p1 = new PackageCapability(c2, "p1");
    c2.addCapability(c2_p1);
    ResourceImpl d1 = new ResourceImpl("D");
    GenericCapability d1_generic = new GenericCapability(d1, "generic");
    d1_generic.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "p1,p2");
    d1.addCapability(d1_generic);
    d1.addRequirement(new PackageRequirement(d1, "p1"));
    d1.addRequirement(new PackageRequirement(d1, "p2"));
    ResourceImpl d2 = new ResourceImpl("D");
    GenericCapability d2_generic = new GenericCapability(d2, "generic");
    d2_generic.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "p1,p2");
    d2.addCapability(d2_generic);
    d2.addRequirement(new PackageRequirement(d2, "p1"));
    d2.addRequirement(new PackageRequirement(d2, "p2"));
    candMap.put(a1.getRequirements(null).get(0), Arrays.asList(c2_p1));
    candMap.put(a1.getRequirements(null).get(1), Arrays.asList(b2_p2));
    candMap.put(a1.getRequirements(null).get(2), Arrays.asList((Capability) d1_generic, (Capability) d2_generic));
    candMap.put(a2.getRequirements(null).get(0), c2.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
    candMap.put(a2.getRequirements(null).get(1), b2.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
    candMap.put(a2.getRequirements(null).get(2), Arrays.asList((Capability) d1_generic, (Capability) d2_generic));
    candMap.put(b1.getRequirements(null).get(0), Arrays.asList(c1_p1, c2_p1));
    candMap.put(b2.getRequirements(null).get(0), Arrays.asList(c1_p1, c2_p1));
    candMap.put(d1.getRequirements(null).get(0), Arrays.asList(c1_p1, c2_p1));
    candMap.put(d1.getRequirements(null).get(1), Arrays.asList(b1_p2, b2_p2));
    candMap.put(d2.getRequirements(null).get(0), Arrays.asList(c1_p1, c2_p1));
    candMap.put(d2.getRequirements(null).get(1), Arrays.asList(b1_p2, b2_p2));
    List<Resource> resources = new ArrayList<Resource>();
    resources.add(a1);
    resources.add(a2);
    return resources;
}

Example 10 with ResourceImpl

use of org.apache.felix.resolver.test.util.ResourceImpl in project felix by apache.

the class ResolverTest method populateScenario3.

private static List<Resource> populateScenario3(Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap) {
    List<Capability> dResourcesCands = new ArrayList<Capability>();
    List<Capability> eBundleDCands = new ArrayList<Capability>();
    List<Capability> eResourcesCands = new ArrayList<Capability>();
    // B
    ResourceImpl b = new ResourceImpl("B");
    PackageCapability pc = new PackageCapability(b, "resources");
    b.addCapability(pc);
    eResourcesCands.add(pc);
    // C
    ResourceImpl c = new ResourceImpl("C");
    pc = new PackageCapability(c, "resources");
    c.addCapability(pc);
    eResourcesCands.add(pc);
    dResourcesCands.add(pc);
    // D
    ResourceImpl d = new ResourceImpl("D");
    pc = new PackageCapability(d, "export");
    pc.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "resources");
    d.addCapability(pc);
    BundleCapability bc = new BundleCapability(d, "D");
    bc.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "resources");
    d.addCapability(bc);
    eBundleDCands.add(bc);
    Requirement r = new PackageRequirement(d, "resources");
    d.addRequirement(r);
    candMap.put(r, dResourcesCands);
    // E
    ResourceImpl e = new ResourceImpl("E");
    r = new BundleRequirement(e, "D");
    e.addRequirement(r);
    candMap.put(r, eBundleDCands);
    r = new PackageRequirement(e, "resources");
    e.addRequirement(r);
    candMap.put(r, eResourcesCands);
    // Mandatory resources
    List<Resource> resources = new ArrayList<Resource>();
    resources.add(e);
    return resources;
}