resolver/src/test/java/org/apache/felix/resolver/test/Main.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.felix.resolver.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.felix.resolver.Logger;
import org.apache.felix.resolver.ResolverImpl;
import org.apache.felix.resolver.test.util.BundleCapability;
import org.apache.felix.resolver.test.util.BundleRequirement;
import org.apache.felix.resolver.test.util.GenericCapability;
import org.apache.felix.resolver.test.util.GenericRequirement;
import org.apache.felix.resolver.test.util.PackageCapability;
import org.apache.felix.resolver.test.util.PackageRequirement;
import org.apache.felix.resolver.test.util.ResolveContextImpl;
import org.apache.felix.resolver.test.util.ResourceImpl;
import org.osgi.framework.Version;
import org.osgi.framework.namespace.BundleNamespace;
import org.osgi.framework.namespace.HostNamespace;
import org.osgi.framework.namespace.IdentityNamespace;
import org.osgi.framework.namespace.PackageNamespace;
import org.osgi.resource.Capability;
import org.osgi.resource.Namespace;
import org.osgi.resource.Requirement;
import org.osgi.resource.Resource;
import org.osgi.resource.Wire;
import org.osgi.resource.Wiring;
import org.osgi.service.resolver.ResolutionException;
import org.osgi.service.resolver.Resolver;

public class Main
{
    public static void main(String[] args) throws ResolutionException
    {
        Resolver resolver = new ResolverImpl(new Logger(Logger.LOG_DEBUG));

        Map<Resource, Wiring> wirings = new HashMap<Resource, Wiring>();
        Map<Requirement, List<Capability>> candMap = new HashMap<Requirement, List<Capability>>();
        List<Resource> mandatory;
        ResolveContextImpl rci;
        Map<Resource, List<Wire>> wireMap;

        System.out.println("\nSCENARIO 1\n");
        mandatory = populateScenario1(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        wireMap = resolver.resolve(rci);
        System.out.println("RESULT " + wireMap);

        System.out.println("\nSCENARIO 2\n");
        mandatory = populateScenario2(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        wireMap = resolver.resolve(rci);
        System.out.println("RESULT " + wireMap);

        System.out.println("\nSCENARIO 3\n");
        mandatory = populateScenario3(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        wireMap = resolver.resolve(rci);
        System.out.println("RESULT " + wireMap);

        System.out.println("\nSCENARIO 4\n");
        mandatory = populateScenario4(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        try
        {
            wireMap = resolver.resolve(rci);
            System.err.println("UNEXPECTED RESULT " + wireMap);
        }
        catch (ResolutionException e)
        {
            System.out.println("EXPECTED ResolutionException:");
            e.printStackTrace(System.out);
        }

        System.out.println("\nSCENARIO 5\n");
        mandatory = populateScenario5(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        try
        {
            wireMap = resolver.resolve(rci);
            System.err.println("UNEXPECTED RESULT " + wireMap);
        }
        catch (ResolutionException e)
        {
            System.out.println("EXPECTED ResolutionException:");
            e.printStackTrace(System.out);
        }

        System.out.println("\nSCENARIO 6\n");
        mandatory = populateScenario6(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        wireMap = resolver.resolve(rci);
        System.out.println("RESULT " + wireMap);

        System.out.println("\nSCENARIO 7\n");
        mandatory = populateScenario7(wirings, candMap);
        rci = new ResolveContextImpl(wirings, candMap, mandatory, Collections.EMPTY_LIST);
        wireMap = resolver.resolve(rci);
        System.out.println("RESULT " + wireMap);
    }

    private static List<Resource> populateScenario1(
        Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        ResourceImpl exporter = new ResourceImpl("A");
        exporter.addCapability(new PackageCapability(exporter, "foo"));
        ResourceImpl importer = new ResourceImpl("B");
        importer.addRequirement(new PackageRequirement(importer, "foo"));
        candMap.put(
            importer.getRequirements(null).get(0),
            exporter.getCapabilities(PackageNamespace.PACKAGE_NAMESPACE));
        List<Resource> resources = new ArrayList<Resource>();
        resources.add(importer);
        return resources;
    }

    private static List<Resource> populateScenario2(
        Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        List<Capability> fooCands = new ArrayList<Capability>();
        List<Capability> barCands = new ArrayList<Capability>();

        // A
        ResourceImpl a = new ResourceImpl("A");
        PackageCapability p = new PackageCapability(a, "foo");
        a.addCapability(p);
        fooCands.add(p);

        // B
        ResourceImpl b = new ResourceImpl("B");
        p = new PackageCapability(b, "foo");
        b.addCapability(p);
        fooCands.add(p);

        p = new PackageCapability(b, "bar");
        p.addDirective(PackageNamespace.CAPABILITY_USES_DIRECTIVE, "foo");
        b.addCapability(p);
        barCands.add(p);

        // C
        ResourceImpl c = new ResourceImpl("C");
        Requirement r = new PackageRequirement(c, "foo");
        c.addRequirement(r);
        candMap.put(r, fooCands);

        r = new PackageRequirement(c, "bar");
        c.addRequirement(r);
        candMap.put(r, barCands);

        // Mandatory resources
        List<Resource> resources = new ArrayList<Resource>();
        resources.add(c);
        return resources;
    }

    private static List<Resource> populateScenario3(
        Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        List<Capability> resourcesCands = new ArrayList<Capability>();
        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;
    }

    private static List<Resource> populateScenario4(
            Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        ResourceImpl a = new ResourceImpl("A");
        a.addRequirement(new BundleRequirement(a, "B"));
        a.addRequirement(new BundleRequirement(a, "C"));

        ResourceImpl b = new ResourceImpl("B");
        b.addCapability(new BundleCapability(b, "B"));
        b.addCapability(new PackageCapability(b, "p1"));

        ResourceImpl c = new ResourceImpl("C");
        c.addRequirement(new BundleRequirement(c, "D"));
        c.addCapability(new BundleCapability(c, "C"));
        PackageCapability p2 = new PackageCapability(c, "p2");
        p2.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "p1");
        c.addCapability(p2);

        ResourceImpl d = new ResourceImpl("D");
        d.addCapability(new BundleCapability(d, "D"));
        d.addCapability(new PackageCapability(d, "p1"));

        candMap.put(
            a.getRequirements(null).get(0),
            b.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
        candMap.put(
            a.getRequirements(null).get(1),
            c.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
        candMap.put(
            c.getRequirements(null).get(0),
            d.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));

        List<Resource> resources = new ArrayList<Resource>();
        resources.add(a);
        return resources;
    }

    private static List<Resource> populateScenario5(
        Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        ResourceImpl x = new ResourceImpl("X");
        x.addRequirement(new BundleRequirement(x, "A"));

        ResourceImpl a = new ResourceImpl("A");
        a.addCapability(new BundleCapability(a, "A"));
        a.addRequirement(new BundleRequirement(a, "B"));
        a.addRequirement(new BundleRequirement(a, "C"));

        ResourceImpl b = new ResourceImpl("B");
        b.addCapability(new BundleCapability(b, "B"));
        b.addCapability(new PackageCapability(b, "p1"));

        ResourceImpl c = new ResourceImpl("C");
        c.addRequirement(new BundleRequirement(c, "D"));
        c.addCapability(new BundleCapability(c, "C"));
        PackageCapability p2 = new PackageCapability(c, "p2");
        p2.addDirective(Namespace.CAPABILITY_USES_DIRECTIVE, "p1");
        c.addCapability(p2);

        ResourceImpl d = new ResourceImpl("D");
        d.addCapability(new BundleCapability(d, "D"));
        d.addCapability(new PackageCapability(d, "p1"));

        candMap.put(
                x.getRequirements(null).get(0),
                a.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
        candMap.put(
            a.getRequirements(null).get(0),
            b.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
        candMap.put(
            a.getRequirements(null).get(1),
            c.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));
        candMap.put(
            c.getRequirements(null).get(0),
            d.getCapabilities(BundleNamespace.BUNDLE_NAMESPACE));

        List<Resource> resources = new ArrayList<Resource>();
        resources.add(x);
        return resources;
    }

    private static List<Resource> populateScenario6(
            Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        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");

        ResourceImpl c2 = new ResourceImpl("C");
        c2.addCapability(new BundleCapability(c2, "C"));
        Capability c2_p1 = new PackageCapability(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;
    }

    private static List<Resource> populateScenario7(
            Map<Resource, Wiring> wirings, Map<Requirement, List<Capability>> candMap)
    {
        wirings.clear();
        candMap.clear();

        ResourceImpl a1 = new ResourceImpl("A");
        GenericCapability a1_hostCap = new GenericCapability(a1, HostNamespace.HOST_NAMESPACE);
        a1_hostCap.addAttribute(HostNamespace.HOST_NAMESPACE, "A");
        a1.addCapability(a1_hostCap);

        ResourceImpl f1 = new ResourceImpl("F1", IdentityNamespace.TYPE_FRAGMENT, Version.emptyVersion);
        GenericRequirement f1_hostReq = new GenericRequirement(f1, HostNamespace.HOST_NAMESPACE);
        f1_hostReq.addDirective(Namespace.REQUIREMENT_FILTER_DIRECTIVE, "(" + HostNamespace.HOST_NAMESPACE + "=A)");
        f1.addRequirement(f1_hostReq);

        ResourceImpl f2 = new ResourceImpl("F2", IdentityNamespace.TYPE_FRAGMENT, Version.emptyVersion);
        GenericRequirement f2_hostReq = new GenericRequirement(f2, HostNamespace.HOST_NAMESPACE);
        f2_hostReq.addDirective(Namespace.REQUIREMENT_FILTER_DIRECTIVE, "(" + HostNamespace.HOST_NAMESPACE + "=A)");
        f2.addRequirement(f2_hostReq);

        ResourceImpl b1 = new ResourceImpl("B");
        GenericRequirement b1_identityReq = new GenericRequirement(f2, IdentityNamespace.IDENTITY_NAMESPACE);
        b1_identityReq.addDirective(Namespace.REQUIREMENT_FILTER_DIRECTIVE, "(" + IdentityNamespace.IDENTITY_NAMESPACE + "=F2)");
        b1.addRequirement(b1_identityReq);

        candMap.put(
            f1.getRequirements(null).get(0),
            a1.getCapabilities(HostNamespace.HOST_NAMESPACE));
        candMap.put(
            f2.getRequirements(null).get(0),
            a1.getCapabilities(HostNamespace.HOST_NAMESPACE));
        candMap.put(
            b1.getRequirements(null).get(0),
            f2.getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE));
        List<Resource> resources = new ArrayList<Resource>();
        resources.add(a1);
        resources.add(f1);
        resources.add(f2);
        resources.add(b1);
        return resources;
    }
}