| /* |
| * 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.dm.itest.api; |
| |
| import java.io.IOException; |
| import java.util.Dictionary; |
| import java.util.Hashtable; |
| |
| import org.junit.Assert; |
| |
| import org.apache.felix.dm.Component; |
| import org.apache.felix.dm.DependencyManager; |
| import org.apache.felix.dm.itest.util.Ensure; |
| import org.apache.felix.dm.itest.util.TestBase; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.service.cm.Configuration; |
| import org.osgi.service.cm.ConfigurationAdmin; |
| import org.osgi.service.metatype.AttributeDefinition; |
| import org.osgi.service.metatype.MetaTypeInformation; |
| import org.osgi.service.metatype.MetaTypeService; |
| import org.osgi.service.metatype.ObjectClassDefinition; |
| |
| /** |
| * Tests an Adapter which adapts A To B interface. |
| * And the Adapter also depends on a Configuration Dependency with MetaType support. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| public class AdapterWithConfigurationAndMetaType extends TestBase { |
| final static String PID = "AdapterWithConfigurationAndMetaType"; |
| final static String PID_HEADING = "English Dictionary"; |
| final static String PID_DESC = "Configuration for the EnglishDictionary Service"; |
| final static String WORDS_HEADING = "English words"; |
| final static String WORDS_DESC = "Declare here some valid English words"; |
| final static String WORDS_PROPERTY = "words"; |
| |
| public void testAdapterWithConfigurationDependencyAndMetaType() { |
| DependencyManager m = getDM(); |
| Ensure e = new Ensure(); |
| |
| m.add(m.createAdapterService(A.class, null) |
| .setInterface(B.class.getName(), null) |
| .setImplementation(new BImpl(e)) |
| .add(m.createConfigurationDependency() |
| .setPid(PID) |
| .setHeading(PID_HEADING) |
| .setDescription(PID_DESC) |
| .add(m.createPropertyMetaData() |
| .setCardinality(Integer.MAX_VALUE) |
| .setType(String.class) |
| .setHeading(WORDS_HEADING) |
| .setDescription(WORDS_DESC) |
| .setDefaults(new String[] {"hello", "world"}) |
| .setId(WORDS_PROPERTY)))); |
| |
| m.add(m.createComponent() |
| .setInterface(A.class.getName(), null) |
| .setImplementation(new AImpl())); |
| |
| Component configurator = m.createComponent() |
| .setImplementation(new Configurator(e)) |
| .add(m.createServiceDependency().setService(ConfigurationAdmin.class).setRequired(true)) |
| .add(m.createServiceDependency().setService(MetaTypeService.class).setRequired(true)); |
| m.add(configurator); |
| |
| // Ensures that all components are started |
| e.waitForStep(4, 5000); |
| |
| // now stop configurator, and ensure that all components have been stopped |
| m.remove(configurator); |
| e.waitForStep(7, 5000); |
| m.clear(); |
| } |
| |
| public interface A { |
| } |
| |
| public interface B { |
| } |
| |
| public class AImpl implements A { |
| } |
| |
| public class Configurator { |
| volatile MetaTypeService m_metaType; |
| volatile ConfigurationAdmin m_cm; |
| volatile BundleContext m_ctx; |
| final Ensure m_ensure; |
| Configuration m_conf; |
| |
| Configurator(Ensure ensure) { |
| m_ensure = ensure; |
| } |
| |
| void start() { |
| m_ensure.step(1); |
| checkMetaTypeAndConfigure(); |
| } |
| |
| void stop() { |
| m_ensure.step(5); |
| if (m_conf != null) { |
| try { |
| m_ensure.step(6); |
| m_conf.delete(); |
| } |
| catch (IOException e) { |
| m_ensure.throwable(e); |
| } |
| } |
| } |
| |
| void checkMetaTypeAndConfigure() { |
| MetaTypeInformation info = m_metaType.getMetaTypeInformation(m_ctx.getBundle()); |
| Assert.assertNotNull(info); |
| Assert.assertEquals(PID, info.getPids()[0]); |
| ObjectClassDefinition ocd = info.getObjectClassDefinition(PID, null); |
| Assert.assertNotNull(ocd); |
| Assert.assertEquals(PID_HEADING, ocd.getName()); |
| Assert.assertEquals(PID_DESC, ocd.getDescription()); |
| AttributeDefinition[] defs = ocd.getAttributeDefinitions(ObjectClassDefinition.ALL); |
| Assert.assertNotNull(defs); |
| Assert.assertEquals(1, defs.length); |
| Assert.assertEquals(WORDS_HEADING, defs[0].getName()); |
| Assert.assertEquals(WORDS_DESC, defs[0].getDescription()); |
| Assert.assertEquals(WORDS_PROPERTY, defs[0].getID()); |
| m_ensure.step(2); |
| |
| try { |
| m_conf = m_cm.getConfiguration(PID, null); |
| Hashtable<String, String> props = new Hashtable<>(); |
| props.put("foo", "bar"); |
| m_conf.update(props); |
| } catch (Throwable t) { |
| m_ensure.throwable(t); |
| } |
| } |
| } |
| |
| public class BImpl implements B, A { |
| final Ensure m_ensure; |
| volatile A m_a; |
| Dictionary<String, String> m_conf; |
| |
| public BImpl(Ensure e) { |
| m_ensure = e; |
| } |
| |
| public void updated(Dictionary<String, String> conf) { |
| if (conf != null) { |
| m_ensure.step(3); |
| m_conf = conf; |
| } |
| } |
| |
| public void start() { |
| Assert.assertNotNull(m_a); |
| Assert.assertNotNull(m_conf); |
| Assert.assertEquals("bar", m_conf.get("foo")); |
| m_ensure.step(4); |
| } |
| |
| public void stop() { |
| m_ensure.step(7); |
| } |
| } |
| } |