/*
 * Copyright 2005-2010 the original author or authors.
 * 
 * Licensed 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.wamblee.system.adapters;

import org.wamblee.system.core.DefaultProvidedInterface;
import org.wamblee.system.core.ProvidedInterface;
import org.wamblee.system.core.RequiredInterface;
import org.wamblee.system.core.SystemAssemblyException;

import org.wamblee.test.AssertionUtils;

import java.util.List;

/**
 * 
 * @author $author$
 * @version $Revision$
 */
public class ConstructorConfigurationTest extends AdapterTestCase {
    public void testGreedyUnique() {
        ConstructorConfiguration config = new ConstructorConfiguration(X1.class)
            .greedy();
        ProvidedInterface provided = new DefaultProvidedInterface("arg",
            String.class);
        List<RequiredInterface> required = config.getRequiredInterfaces();

        assertEquals(1, required.size());
        assertFalse(required.get(0).isOptional());

        required.get(0).setProvider(provided);

        scope.publishInterface(provided, "hello");
        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x1(hello)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }

    public void testGreedyNonUnique() {
        try {
            ConstructorConfiguration config = new ConstructorConfiguration(
                X2.class).greedy();
        } catch (SystemAssemblyException e) {
            // e.printStackTrace();
            return;
        }

        fail();
    }

    public void testSpecificConstructor() {
        ConstructorConfiguration config = new ConstructorConfiguration(X2.class)
            .select(String.class);
        ProvidedInterface provided = new DefaultProvidedInterface("arg",
            String.class);
        List<RequiredInterface> required = config.getRequiredInterfaces();

        assertEquals(1, required.size());
        required.get(0).setProvider(provided);

        scope.publishInterface(provided, "hello");
        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x2(hello)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }

    public void testSetValue() {
        ConstructorConfiguration config = new ConstructorConfiguration(X1.class)
            .greedy();
        config.getParameters().setValue(0, "bla");

        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x1(bla)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }

    public void testOptionalValueProvided() {
        ConstructorConfiguration config = new ConstructorConfiguration(X1.class)
            .greedy();
        config.getParameters().setOptional(0);

        ProvidedInterface provided = new DefaultProvidedInterface("arg",
            String.class);
        List<RequiredInterface> required = config.getRequiredInterfaces();

        assertEquals(1, required.size());
        required.get(0).setProvider(provided);

        scope.publishInterface(provided, "hello");
        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x1(hello)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }

    public void testOptionalValueMissing() {
        ConstructorConfiguration config = new ConstructorConfiguration(X1.class)
            .greedy();
        config.getParameters().setOptional(0);
        assertTrue(config.getRequiredInterfaces().get(0).isOptional());

        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x1(null)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }

    public void testIgnoredNonPublic() {
        ConstructorConfiguration config = new ConstructorConfiguration(X3.class)
            .greedy();
        List<RequiredInterface> required = config.getRequiredInterfaces();
        assertEquals(0, config.getParameters().getTypes().length);
    }

    public void testNonPublicConstructor() {
        ConstructorConfiguration config = new ConstructorConfiguration(X3.class)
            .setNonPublic(true).greedy();
        ProvidedInterface provided = new DefaultProvidedInterface("arg",
            String.class);
        List<RequiredInterface> required = config.getRequiredInterfaces();

        assertEquals(1, required.size());
        assertFalse(required.get(0).isOptional());

        required.get(0).setProvider(provided);

        scope.publishInterface(provided, "hello");
        config.create(scope);

        AssertionUtils.assertEquals(new String[] { "x3(hello)" },
            AdapterTestCase.EVENT_TRACKER.getEvents(Thread.currentThread())
                .toArray());
    }
}