FELIX_4914_Test.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.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;
import org.apache.felix.resolver.Logger;
import org.apache.felix.resolver.ResolverImpl;
import org.apache.felix.resolver.Util;
import org.apache.felix.resolver.test.util.CapabilitySet;
import org.apache.felix.resolver.test.util.JsonReader;
import org.apache.felix.resolver.test.util.ResolveContextImpl;
import org.apache.felix.resolver.test.util.SimpleFilter;
import org.junit.Test;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.resource.Capability;
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.Resolver;

public class FELIX_4914_Test extends TestCase {

    @Test
    public void testResolution() throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("/felix-4914.json")));
        Map<String, Object> resolution = (Map<String, Object>) JsonReader.read(reader);
        List<Resource> repository = readRepository(resolution.get("repository"));

        Map<String, CapabilitySet> capSets = new HashMap<String, CapabilitySet>();
        for (Resource resource : repository) {
            for (Capability cap : resource.getCapabilities(null)) {
                String ns = cap.getNamespace();
                CapabilitySet set = capSets.get(ns);
                if (set == null) {
                    set = new CapabilitySet(Collections.singletonList(ns));
                    capSets.put(ns, set);
                }
                set.addCapability(cap);
            }
        }

        Resource root = null;
        for (Resource resource : repository) {
            if ("root".equals(Util.getSymbolicName(resource))) {
                root = resource;
                break;
            }
        }
        List<Resource> mandatory = new ArrayList<Resource>();
        mandatory.add(root);


        Map<Requirement, List<Capability>> candidates = new HashMap<Requirement, List<Capability>>();
        for (Resource resource : repository) {
            for (Requirement requirement : resource.getRequirements(null)) {
                CapabilitySet set = capSets.get(requirement.getNamespace());
                if (set != null) {
                    String filter = requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);
                    SimpleFilter sf = (filter != null)
                            ? SimpleFilter.parse(filter)
                            : SimpleFilter.convert(requirement.getAttributes());
                    candidates.put(requirement, new ArrayList<Capability>(set.match(sf, true)));
                } else {
                    candidates.put(requirement, Collections.<Capability>emptyList());
                }
            }
        }

        ResolveContextImpl rci = new ResolveContextImpl(Collections.<Resource, Wiring>emptyMap(), candidates, mandatory, Collections.EMPTY_LIST);
        Resolver resolver = new ResolverImpl(new Logger(Logger.LOG_DEBUG));
        Map<Resource, List<Wire>> wireMap = resolver.resolve(rci);


    }

    private static List<Resource> readRepository(Object repository) throws BundleException {
        List<Resource> resources = new ArrayList<Resource>();
        Collection<Map<String, List<String>>> metadatas;
        if (repository instanceof Map) {
            metadatas = ((Map<String, Map<String, List<String>>>) repository).values();
        } else {
            metadatas = (Collection<Map<String, List<String>>>) repository;
        }
        for (Map<String, List<String>> metadata : metadatas) {
            resources.add(BigResolutionTest.parseResource(metadata));
            /*
            ResourceImpl res = new ResourceImpl() {
                @Override
                public String toString() {
                    Capability cap = getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE).get(0);
                    return cap.getAttributes().get(IdentityNamespace.IDENTITY_NAMESPACE) + "/"
                            + cap.getAttributes().get(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE);
                }
            };
            for (String cap : metadata.get("capabilities")) {
                for (Capability c : ResourceBuilder.parseCapability(res, cap)) {
                    res.addCapability(c);
                }
            }
            if (metadata.containsKey("requirements")) {
                for (String req : metadata.get("requirements")) {
                    for (Requirement r : ResourceBuilder.parseRequirement(res, req)) {
                        res.addRequirement(r);
                    }
                }
            }
            resources.add(res);
            */
        }
        return resources;
    }

}