/*
 * 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.ipojo.handler.eventadmin.test;

import org.apache.felix.ipojo.*;
import org.apache.felix.ipojo.handler.eventadmin.test.donut.Donut;
import org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutConsumer;
import org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutProvider;
import org.apache.felix.ipojo.metadata.Attribute;
import org.apache.felix.ipojo.metadata.Element;
import org.apache.felix.ipojo.parser.ManifestMetadataParser;
import org.apache.felix.ipojo.parser.ParseException;
import org.junit.Before;
import org.junit.Test;
import org.osgi.framework.ServiceReference;

import java.util.Dictionary;
import java.util.Hashtable;

import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.fail;

/**
 * Test the good behaviour of the EventAdminHandler.
 *
 * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
 */
public class TestBadConfigurations extends Common {

    /**
     * The namespace of the Event admin handler.
     */
    private static final String NAMESPACE = "org.apache.felix.ipojo.handlers.event";
    /**
     * The utility class instance.
     */
    public EahTestUtils m_utils;
    /**
     * The available components.
     */
    private Element[] m_components;
    /**
     * The description of a component that uses an event publisher.
     */
    private Element m_provider;
    /**
     * The event publisher description.
     */
    private Element m_publisher;
    /**
     * The name attribute of the event publisher.
     */
    private Attribute m_publisherName;
    /**
     * The field attribute of the event publisher.
     */
    private Attribute m_publisherField;
    /**
     * The topics attribute of the event publisher.
     */
    private Attribute m_publisherTopics;
    /**
     * The data-key attribute of the event publisher.
     */
    private Attribute m_publisherDataKey;
    /**
     * The synchronous attribute of the event publisher.
     */
    private Attribute m_publisherSynchronous;
    /**
     * The description of a component that uses an event subscriber.
     */
    private Element m_consumer;
    /**
     * The event subscriber description.
     */
    private Element m_subscriber;
    /**
     * The name attribute of the event subscriber.
     */
    private Attribute m_subscriberName;
    /**
     * The callback attribute of the event subscriber.
     */
    private Attribute m_subscriberCallback;
    /**
     * The topics attribute of the event subscriber.
     */
    private Attribute m_subscriberTopics;
    /**
     * The data-key attribute of the event subscriber.
     */
    private Attribute m_subscriberDataKey;
    /**
     * The data-type attribute of the event subscriber.
     */
    private Attribute m_subscriberDataType;

    private Element getManipulationForComponent(String compName) {
        for (int i = 0; i < m_components.length; i++) {
            if (m_components[i].containsAttribute("name")
                    && m_components[i].getAttribute("name").equals(compName)) {
                return m_components[i].getElements("manipulation")[0];
            }
        }
        return null;
    }

    /**
     * Initialization before test cases.
     * <p/>
     * Create all the instances
     */
    @Before
    public void setUp() {
        m_utils = new EahTestUtils(bc, ipojoHelper);
        /**
         * Get the list of available components.
         */
        try {
            String header = (String) getTestBundle().getHeaders().get(
                    "iPOJO-Components");
            m_components = ManifestMetadataParser.parseHeaderMetadata(header)
                    .getElements("component");
        } catch (ParseException e) {
            fail("Parse Exception when parsing iPOJO-Component");
        }

        /**
         * Initialize the standard publishing component (based on the
         * asynchronous donut provider).
         */
        m_provider = new Element("component", "");
        m_provider.addAttribute(new Attribute("className",
                "org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutProviderImpl"));
        m_provider.addAttribute(new Attribute("name",
                "standard donut provider for bad tests"));

        // The provided service of the publisher
        Element providesDonutProvider = new Element("provides", "");
        providesDonutProvider.addAttribute(new Attribute("interface",
                "org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutProvider"));
        Element providesDonutProviderProperty = new Element("property", "");
        providesDonutProviderProperty
                .addAttribute(new Attribute("name", "name"));
        providesDonutProviderProperty.addAttribute(new Attribute("field",
                "m_name"));
        providesDonutProviderProperty.addAttribute(new Attribute("value",
                "Unknown donut vendor"));
        providesDonutProvider.addElement(providesDonutProviderProperty);
        m_provider.addElement(providesDonutProvider);

        // The event publisher, corresponding to the following description :
        // <ev:publisher name="donut-publisher" field="m_publisher"
        // topics="food/donuts" data-key="food" synchronous="false"/>
        m_publisher = new Element("publisher", NAMESPACE);
        m_publisherName = new Attribute("name", "donut-publisher");
        m_publisherField = new Attribute("field", "m_publisher");
        m_publisherTopics = new Attribute("topics", "food/donuts");
        m_publisherDataKey = new Attribute("data-key", "food");
        m_publisherSynchronous = new Attribute("synchronous", "false");
        m_publisher.addAttribute(m_publisherName);
        m_publisher.addAttribute(m_publisherField);
        m_publisher.addAttribute(m_publisherTopics);
        m_publisher.addAttribute(m_publisherDataKey);
        m_publisher.addAttribute(m_publisherSynchronous);
        m_provider.addElement(m_publisher);

        m_provider.addElement(getManipulationForComponent("donut-provider"));

        /**
         * Initialize the standard subscribing component (based on the donut
         * consumer).
         */
        m_consumer = new Element("component", "");
        m_consumer.addAttribute(new Attribute("className",
                "org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutConsumerImpl"));
        m_consumer.addAttribute(new Attribute("name",
                "standard donut consumer for bad tests"));

        // The provided service of the publisher
        Element providesDonutConsumer = new Element("provides", "");
        providesDonutConsumer.addAttribute(new Attribute("interface",
                "org.apache.felix.ipojo.handler.eventadmin.test.donut.DonutConsumer"));
        Element providesDonutConsumerNameProperty = new Element("property", "");
        providesDonutConsumerNameProperty.addAttribute(new Attribute("name",
                "name"));
        providesDonutConsumerNameProperty.addAttribute(new Attribute("field",
                "m_name"));
        providesDonutConsumerNameProperty.addAttribute(new Attribute("value",
                "Unknown donut consumer"));
        providesDonutConsumer.addElement(providesDonutConsumerNameProperty);
        Element providesDonutConsumerSlowProperty = new Element("property", "");
        providesDonutConsumerSlowProperty.addAttribute(new Attribute("name",
                "slow"));
        providesDonutConsumerSlowProperty.addAttribute(new Attribute("field",
                "m_isSlow"));
        providesDonutConsumerSlowProperty.addAttribute(new Attribute("value",
                "false"));
        providesDonutConsumer.addElement(providesDonutConsumerSlowProperty);
        m_consumer.addElement(providesDonutConsumer);

        // The event publisher, corresponding to the following description :
        // <ev:subscriber name="donut-subscriber" callback="receiveDonut"
        // topics="food/donuts" data-key="food"
        // data-type="org.apache.felix.ipojo.handler.eventadmin.test.donut.Donut"/>
        m_subscriber = new Element("subscriber", NAMESPACE);
        m_subscriberName = new Attribute("name", "donut-subscriber");
        m_subscriberCallback = new Attribute("callback", "receiveDonut");
        m_subscriberTopics = new Attribute("topics", "food/donuts");
        m_subscriberDataKey = new Attribute("data-key", "food");
        m_subscriberDataType = new Attribute("data-type",
                "org.apache.felix.ipojo.handler.eventadmin.test.donut.Donut");
        m_subscriber.addAttribute(m_subscriberName);
        m_subscriber.addAttribute(m_subscriberCallback);
        m_subscriber.addAttribute(m_subscriberTopics);
        m_subscriber.addAttribute(m_subscriberDataKey);
        m_subscriber.addAttribute(m_subscriberDataType);
        m_consumer.addElement(m_subscriber);

        m_consumer.addElement(getManipulationForComponent("donut-consumer"));
    }

    /**
     * Test the base configuration is correct to be sure the bad tests will fail
     * because of they are really bad, and not because of an other application
     * error.
     * <p/>
     * This test simply create a provider and a consumer instance, send one
     * event and check it is received.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testGoodConfig()
            throws ConfigurationException, UnacceptableConfiguration,
            MissingHandlerException {
        /**
         * Create the provider and the consumer instances.
         */
        Dictionary properties = new Hashtable();

        // Provider
        ComponentFactory providerFactory = new ComponentFactory(bc,
                m_provider);
        providerFactory.start();
        properties.put("instance.name", "Emperor of donuts");
        ComponentInstance providerInstance = providerFactory
                .createComponentInstance(properties);
        ServiceReference providerService = ipojoHelper
                .getServiceReferenceByName(DonutProvider.class
                        .getName(), providerInstance.getInstanceName());
        DonutProvider provider = (DonutProvider) bc
                .getService(providerService);

        // The consumer
        properties = new Hashtable();
        ComponentFactory consumerFactory = new ComponentFactory(bc,
                m_consumer);
        consumerFactory.start();
        properties.put("instance.name", "Homer Simpson");
        properties.put("slow", "false");
        ComponentInstance consumerInstance = consumerFactory
                .createComponentInstance(properties);
        ServiceReference consumerService = ipojoHelper
                .getServiceReferenceByName(DonutConsumer.class
                        .getName(), consumerInstance.getInstanceName());
        DonutConsumer consumer = (DonutConsumer) bc
                .getService(consumerService);

        /**
         * Test the normal behaviour of the instances.
         */
        consumer.clearDonuts();
        Donut sentDonut = provider.sellDonut();
        Donut receivedDonut = consumer.waitForDonut();
        assertEquals("The received donut must be the same as the sent one.",
                sentDonut, receivedDonut);

        /**
         * Destroy component's instances.
         */
        bc.ungetService(providerService);
        providerInstance.dispose();
        bc.ungetService(consumerService);
        consumerInstance.dispose();
        providerFactory.stop();
        consumerFactory.stop();
    }

    /**
     * Try to create a publisher with no name.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithoutName()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher
        m_publisher.removeAttribute(m_publisherName);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when no name is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.addAttribute(m_publisherName);
        }
    }

    /**
     * Try to create a publisher with no field.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithoutField()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher
        m_publisher.removeAttribute(m_publisherField);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when no field is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.addAttribute(m_publisherField);
        }
    }

    /**
     * Try to create a publisher with an unexisting field.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithUnexistingField()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher and replace with an
        // unexisting field name
        m_publisher.removeAttribute(m_publisherField);
        Attribute unexistingField = new Attribute("field", "m_unexistingField");
        m_publisher.addAttribute(unexistingField);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when an unexisting field is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.removeAttribute(unexistingField);
            m_publisher.addAttribute(m_publisherField);
        }
    }

    /**
     * Try to create a publisher with a bad typed field.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithBadTypedField()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher and replace with an
        // bad typed field name
        m_publisher.removeAttribute(m_publisherField);
        Attribute badTypedField = new Attribute("field", "m_name");
        m_publisher.addAttribute(badTypedField);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when an bad typed field is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.removeAttribute(badTypedField);
            m_publisher.addAttribute(m_publisherField);
        }
    }

    /**
     * Try to create a publisher instance without topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithoutTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the publisher
        m_publisher.removeAttribute(m_publisherTopics);
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        fact.start();

        // Try to create an instance without specified topics
        Dictionary conf = new Hashtable();
        conf.put("instance.name", "provider without topics");

        ComponentInstance instance;
        try {
            instance = fact.createComponentInstance(conf);
            // Should not be executed
            instance.dispose();
            fail("The factory must not create instance without specified topics.");
        } catch (ConfigurationException e) {
            // OK
        } finally {
            fact.stop();
            // Restore the original state of the publisher
            m_publisher.addAttribute(m_publisherTopics);
        }
    }

    /**
     * Try to create a publisher with malformed topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithMalformedTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the publisher and replace with a
        // malformed one
        m_publisher.removeAttribute(m_publisherTopics);
        Attribute malformedTopics = new Attribute("topics",
                "| |\\| \\/ /-\\ |_ | |)");
        m_publisher.addAttribute(malformedTopics);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when invalid topics are specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.removeAttribute(malformedTopics);
            m_publisher.addAttribute(m_publisherTopics);
        }
    }

    /**
     * Try to create a publisher with a pattern topic (ending with '*') instead of a fixed topic.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithPatternTopic()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the publisher and replace with a
        // malformed one
        m_publisher.removeAttribute(m_publisherTopics);
        Attribute malformedTopics = new Attribute("topics",
                "a/pattern/topic/*");
        m_publisher.addAttribute(malformedTopics);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when invalid topics are specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_publisher.removeAttribute(malformedTopics);
            m_publisher.addAttribute(m_publisherTopics);
        }
    }

    /**
     * Try to create a publisher with malformed instance topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testPublisherWithMalformedInstanceTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the publisher and replace with a
        // malformed one
        m_publisher.removeAttribute(m_publisherTopics);
        ComponentFactory fact = new ComponentFactory(bc, m_provider);
        fact.start();

        // Try to create an instance with malformed specified topics
        Dictionary conf = new Hashtable();
        conf.put("instance.name", "provider with malformed topics");
        Dictionary topics = new Hashtable();
        topics.put("donut-publisher", "| |\\| \\/ /-\\ |_ | |)");
        conf.put("event.topics", topics);

        ComponentInstance instance;
        try {
            instance = fact.createComponentInstance(conf);
            // Should not be executed
            instance.dispose();
            fail("The factory must not create instance with invalid specified topics.");
        } catch (ConfigurationException e) {
            // OK
        } finally {
            fact.stop();
            // Restore the original state of the publisher
            m_publisher.addAttribute(m_publisherTopics);
        }
    }

    /**
     * Try to create a subscriber with no name.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithoutName()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher
        m_subscriber.removeAttribute(m_subscriberName);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when no name is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_subscriber.addAttribute(m_subscriberName);
        }
    }

    /**
     * Try to create a subscriber with no callback.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithoutCallback()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the name attribute of the publisher
        m_subscriber.removeAttribute(m_subscriberCallback);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when no callback is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the publisher
            m_subscriber.addAttribute(m_subscriberCallback);
        }
    }

    /**
     * Try to create a subscriber instance without topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithoutTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the subscriber
        m_subscriber.removeAttribute(m_subscriberTopics);
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        fact.start();

        // Try to create an instance without specified topics
        Dictionary conf = new Hashtable();
        conf.put("instance.name", "consumer without topics");
        conf.put("slow", "false");

        ComponentInstance instance;
        try {
            instance = fact.createComponentInstance(conf);
            // Should not be executed
            instance.dispose();
            fail("The factory must not create instance without specified topics.");
        } catch (ConfigurationException e) {
            // OK
        } finally {
            fact.stop();
            // Restore the original state of the subscriber
            m_subscriber.addAttribute(m_subscriberTopics);
        }
    }

    /**
     * Try to create a subscriber with malformed topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithMalformedTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the subscriber and replace with a
        // malformed one
        m_subscriber.removeAttribute(m_subscriberTopics);
        Attribute malformedTopics = new Attribute("topics",
                "| |\\| \\/ /-\\ |_ | |)");
        m_subscriber.addAttribute(malformedTopics);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when invalid topics are specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the subscriber
            m_subscriber.removeAttribute(malformedTopics);
            m_subscriber.addAttribute(m_subscriberTopics);
        }
    }

    /**
     * Try to create a subscriber with malformed instance topics.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithMalformedInstanceTopics()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the topics attribute of the subscriber and replace with a
        // malformed one
        m_subscriber.removeAttribute(m_subscriberTopics);
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        fact.start();

        // Try to create an instance with malformed specified topics
        Dictionary conf = new Hashtable();
        conf.put("instance.name", "consumer with malformed topics");
        Dictionary topics = new Hashtable();
        topics.put("donut-subscriber", "| |\\| \\/ /-\\ |_ | |)");
        conf.put("event.topics", topics);

        ComponentInstance instance;
        try {
            instance = fact.createComponentInstance(conf);
            // Should not be executed
            instance.dispose();
            fail("The factory must not create instance with invalid specified topics.");
        } catch (ConfigurationException e) {
            // OK
        } finally {
            fact.stop();
            // Restore the original state of the subscriber
            m_subscriber.addAttribute(m_subscriberTopics);
        }
    }

    /**
     * Try to create a subscriber with unknown data type.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithUnknownDataType()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the data-type attribute of the subscriber and replace with a
        // malformed one
        m_subscriber.removeAttribute(m_subscriberDataType);
        Attribute unknownType = new Attribute("data-type", "org.unknown.Clazz");
        m_subscriber.addAttribute(unknownType);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when unknown data type is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the subscriber
            m_subscriber.removeAttribute(unknownType);
            m_subscriber.addAttribute(m_subscriberDataType);
        }
    }

    /**
     * Try to create a subscriber with a data type that does not match with the
     * callback parameter type.
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened
     */
    @Test
    public void testSubscriberWithUnappropriatedDataType()
            throws ConfigurationException, MissingHandlerException,
            UnacceptableConfiguration {

        // Remove the data-type attribute of the subscriber and replace with a
        // malformed one
        m_subscriber.removeAttribute(m_subscriberDataType);
        Attribute unknownType = new Attribute("data-type", "java.lang.String");
        m_subscriber.addAttribute(unknownType);

        // Create and try to start the factory
        ComponentFactory fact = new ComponentFactory(bc, m_consumer);
        try {
            fact.start();
            // Should not be executed
            fact.stop();
            fail("The factory must not start when unappropriated data type is specified.");
        } catch (IllegalStateException e) {
            // OK
        } finally {
            // Restore the original state of the subscriber
            m_subscriber.removeAttribute(unknownType);
            m_subscriber.addAttribute(m_subscriberDataType);
        }
    }

    // DEBUG
    public void dumpElement(String message, Element root) {
        System.err.println(message + "\n" + dumpElement(0, root));
    }

    // DEBUG
    private String dumpElement(int level, Element element) {
        StringBuilder sb = new StringBuilder();
        // Enter tag
        for (int i = 0; i < level; i++) {
            sb.append("  ");
        }
        sb.append('<');
        sb.append(element.getName());
        Attribute[] attributes = element.getAttributes();
        for (int i = 0; i < attributes.length; i++) {
            Attribute attribute = attributes[i];
            sb.append(' ');
            sb.append(attribute.getName());
            sb.append('=');
            sb.append(attribute.getValue());
        }
        sb.append(">\n");
        // Children
        Element[] elements = element.getElements();
        for (int i = 0; i < elements.length; i++) {
            sb.append(dumpElement(level + 1, elements[i]));
        }
        // Exit tag
        for (int i = 0; i < level; i++) {
            sb.append("  ");
        }
        sb.append("</" + element.getName() + ">\n");
        return sb.toString();
    }

    /**
     * Creates a subscriber listening on a pattern topic (ending with '*').
     *
     * @throws org.apache.felix.ipojo.ConfigurationException
     *          something bad happened.
     * @throws org.apache.felix.ipojo.MissingHandlerException
     *          something bad happened.
     * @throws org.apache.felix.ipojo.UnacceptableConfiguration
     *          something bad happened.
     */
    @Test
    public void testSubscriberWithPatternTopic() throws UnacceptableConfiguration, MissingHandlerException, ConfigurationException {
        Dictionary properties = new Hashtable();
        Dictionary topics = new Hashtable();

        // Create the donut consumer instance, listening on a pattern topic
        properties.put("instance.name", "subscriber with pattern topic");
        topics.put("donut-subscriber", "a/pattern/topic/*rf");
        properties.put("event.topics", topics);
        ComponentInstance instance = null;
        try {
            instance = m_utils.getDonutConsumerFactory()
                    .createComponentInstance(properties);

            // Should not been executed
            instance.dispose();
            fail("An invalid topic scope was accepted)");

        } catch (ConfigurationException e) {
            // Nothing to do
        }

        properties = new Hashtable();
        topics = new Hashtable();

        // Create the donut consumer instance, listening on a pattern topic
        properties.put("instance.name", "subscriber with pattern topic");
        topics.put("donut-subscriber", "a/pattern/*topic/rf");
        properties.put("event.topics", topics);

        try {
            instance = m_utils.getDonutConsumerFactory()
                    .createComponentInstance(properties);
            instance.dispose();
            fail("An invalid topic scope was accepted (2)");
        } catch (ConfigurationException e) {
            // Nothing to do
        }
    }

}