Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1MapSR.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1MapSR.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1MapSR.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1MapSR.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,42 @@ +/* + * 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.scr.impl.manager.components; + +import java.util.Map; + +import org.osgi.framework.ServiceReference; + +public class T1MapSR extends T1 +{ + + void packageT1MapSR( Map props, ServiceReference sr) + { + if ( props != null && !props.isEmpty() && sr != null ) + { + callPerformed = "packageT1MapSR"; + } + else + { + callPerformed = "packageT1MapSR error: props: " + props + " SR " + sr; + } + + } + + +}
Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1a.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1a.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1a.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T1a.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,27 @@ +/* + * 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.scr.impl.manager.components; + + +public class T1a extends T1 +{ + + // this class sees package private methods from T1 + +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T3.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T3.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T3.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components/T3.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,30 @@ +/* + * 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.scr.impl.manager.components; + + +import org.apache.felix.scr.impl.manager.components2.T2; + + +public class T3 extends T2 +{ + + // this class does not see any package private methods of other classes + +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components2/T2.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components2/T2.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components2/T2.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/manager/components2/T2.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,211 @@ +/* + * 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.scr.impl.manager.components2; + + +import java.util.Map; + +import org.apache.felix.scr.impl.manager.components.FakeService; +import org.apache.felix.scr.impl.manager.components.SuperFakeService; +import org.apache.felix.scr.impl.manager.components.T1; +import org.osgi.framework.ServiceReference; + + +public class T2 extends T1 +{ + private void privateT2() + { + callPerformed = "privateT2"; + } + + + private void privateT2SR( ServiceReference sr ) + { + if ( sr != null ) + { + callPerformed = "privateT2SR"; + } + else + { + callPerformed = "privateT2SR with null param"; + } + } + + + private void privateT2SI( FakeService si ) + { + if ( si != null ) + { + callPerformed = "privateT2SI"; + } + else + { + callPerformed = "privateT2SI with null param"; + } + } + + + private void privateT2SIMap( FakeService si, Map props ) + { + if ( si != null && props != null && props.size() > 0 ) + { + callPerformed = "privateT2SIMap"; + } + else if ( si == null ) + { + callPerformed = "privateT2SIMap with null service instance"; + } + else if ( props == null ) + { + callPerformed = "privateT2SIMap with null props"; + } + else + { + callPerformed = "privateT2SIMap with empty props"; + } + } + + + private void privateT2SSI( SuperFakeService si ) + { + if ( si != null ) + { + callPerformed = "privateT2SSI"; + } + else + { + callPerformed = "privateT2SSI with null param"; + } + } + + + private void privateT2SSIMap( SuperFakeService si, Map props ) + { + if ( si != null && props != null && props.size() > 0 ) + { + callPerformed = "privateT2SSIMap"; + } + else if ( si == null ) + { + callPerformed = "privateT2SSIMap with null service instance"; + } + else if ( props == null ) + { + callPerformed = "privateT2SSIMap with null props"; + } + else + { + callPerformed = "privateT2SSIMap with empty props"; + } + } + + + void packageT2() + { + callPerformed = "packageT2"; + } + + + void packageT2SR( ServiceReference sr ) + { + if ( sr != null ) + { + callPerformed = "packageT2SR"; + } + else + { + callPerformed = "packageT2SR with null param"; + } + } + + + void packageT2SI( FakeService si ) + { + if ( si != null ) + { + callPerformed = "packageT2SI"; + } + else + { + callPerformed = "packageT2SI with null param"; + } + } + + + void packageT2SIMap( FakeService si, Map props ) + { + if ( si != null && props != null && props.size() > 0 ) + { + callPerformed = "packageT2SIMap"; + } + else if ( si == null ) + { + callPerformed = "packageT2SIMap with null service instance"; + } + else if ( props == null ) + { + callPerformed = "packageT2SIMap with null props"; + } + else + { + callPerformed = "packageT2SIMap with empty props"; + } + } + + + void packageT2SSI( SuperFakeService si ) + { + if ( si != null ) + { + callPerformed = "packageT2SSI"; + } + else + { + callPerformed = "packageT2SSI with null param"; + } + } + + + void packageT2SSIMap( SuperFakeService si, Map props ) + { + if ( si != null && props != null && props.size() > 0 ) + { + callPerformed = "packageT2SSIMap"; + } + else if ( si == null ) + { + callPerformed = "packageT2SSIMap with null service instance"; + } + else if ( props == null ) + { + callPerformed = "packageT2SSIMap with null props"; + } + else + { + callPerformed = "packageT2SSIMap with empty props"; + } + } + + + // this method must hide the T1#suitable method ! + private void suitable( FakeService si ) + { + callPerformed = "suitableT2"; + } +} \ No newline at end of file Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/ComponentMetadataTest.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/ComponentMetadataTest.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/ComponentMetadataTest.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/ComponentMetadataTest.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,992 @@ +/* + * 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.scr.impl.metadata; + + +import java.lang.reflect.Array; +import java.util.List; + +import junit.framework.TestCase; + +import org.apache.felix.scr.impl.MockLogger; +import org.osgi.service.component.ComponentException; + + +public class ComponentMetadataTest extends TestCase +{ + + private MockLogger logger = new MockLogger(); + + + // test various combinations of component metadata with respect to + // -- immediate: true, false, unset + // -- factory: set, unset + // -- service: set, unset + // -- servicefactory: true, false, unset + + public void testImmediate() + { + // immediate is default true if no service element is defined + final ComponentMetadata cm0 = createComponentMetadata( null, null ); + cm0.validate( logger ); + assertTrue( "Component without service must be immediate", cm0.isImmediate() ); + + // immediate is explicit true + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.validate( logger ); + assertTrue( "Component must be immediate", cm1.isImmediate() ); + + // immediate is explicit true + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.setService( createServiceMetadata( null ) ); + cm2.validate( logger ); + assertTrue( "Component must be immediate", cm2.isImmediate() ); + + // immediate is explicit true + final ComponentMetadata cm3 = createComponentMetadata( Boolean.TRUE, null ); + cm3.setService( createServiceMetadata( Boolean.FALSE ) ); + cm3.validate( logger ); + assertTrue( "Component must be immediate", cm3.isImmediate() ); + + // validation failure of immediate with service factory + final ComponentMetadata cm4 = createComponentMetadata( Boolean.TRUE, null ); + cm4.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm4.validate( logger ); + fail( "Expect validation failure for immediate service factory" ); + } + catch ( ComponentException ce ) + { + // expect + } + } + + + public void testDelayed() + { + // immediate is default false if service element is defined + final ComponentMetadata cm0 = createComponentMetadata( null, null ); + cm0.setService( createServiceMetadata( null ) ); + cm0.validate( logger ); + assertFalse( "Component with service must be delayed", cm0.isImmediate() ); + + // immediate is default false if service element is defined + final ComponentMetadata cm1 = createComponentMetadata( null, null ); + cm1.setService( createServiceMetadata( Boolean.TRUE ) ); + cm1.validate( logger ); + assertFalse( "Component with service must be delayed", cm1.isImmediate() ); + + // immediate is default false if service element is defined + final ComponentMetadata cm2 = createComponentMetadata( null, null ); + cm2.setService( createServiceMetadata( Boolean.FALSE ) ); + cm2.validate( logger ); + assertFalse( "Component with service must be delayed", cm2.isImmediate() ); + + // immediate is false if service element is defined + final ComponentMetadata cm3 = createComponentMetadata( Boolean.FALSE, null ); + cm3.setService( createServiceMetadata( null ) ); + cm3.validate( logger ); + assertFalse( "Component with service must be delayed", cm3.isImmediate() ); + + // immediate is false if service element is defined + final ComponentMetadata cm4 = createComponentMetadata( Boolean.FALSE, null ); + cm4.setService( createServiceMetadata( Boolean.TRUE ) ); + cm4.validate( logger ); + assertFalse( "Component with service must be delayed", cm4.isImmediate() ); + + // immediate is false if service element is defined + final ComponentMetadata cm5 = createComponentMetadata( Boolean.FALSE, null ); + cm5.setService( createServiceMetadata( Boolean.FALSE ) ); + cm5.validate( logger ); + assertFalse( "Component with service must be delayed", cm5.isImmediate() ); + + // explicit delayed fails when there is no service + final ComponentMetadata cm6 = createComponentMetadata( Boolean.FALSE, null ); + try + { + cm6.validate( logger ); + fail( "Expect validation failure for delayed component without service" ); + } + catch ( ComponentException ce ) + { + // expect + } + } + + + public void testFactory() + { + // immediate is default false if factory is defined + final ComponentMetadata cm0 = createComponentMetadata( null, "factory" ); + cm0.validate( logger ); + assertFalse( "Component with factory must be delayed", cm0.isImmediate() ); + + // immediate is false if factory is defined + final ComponentMetadata cm1 = createComponentMetadata( Boolean.FALSE, "factory" ); + cm1.validate( logger ); + assertFalse( "Component with factory must be delayed", cm1.isImmediate() ); + + // immediate is default false if factory is defined + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, "factory" ); + try + { + cm2.validate( logger ); + fail( "Expect validation failure for immediate factory component" ); + } + catch ( ComponentException ce ) + { + // expect + } + + // immediate is default false if factory is defined + final ComponentMetadata cm10 = createComponentMetadata( null, "factory" ); + cm10.setService( createServiceMetadata( null ) ); + cm10.validate( logger ); + assertFalse( "Component with factory must be delayed", cm10.isImmediate() ); + + // immediate is false if factory is defined + final ComponentMetadata cm11 = createComponentMetadata( Boolean.FALSE, "factory" ); + cm11.setService( createServiceMetadata( null ) ); + cm11.validate( logger ); + assertFalse( "Component with factory must be delayed", cm11.isImmediate() ); + + // immediate is default false if factory is defined + final ComponentMetadata cm12 = createComponentMetadata( Boolean.TRUE, "factory" ); + cm12.setService( createServiceMetadata( null ) ); + try + { + cm12.validate( logger ); + fail( "Expect validation failure for immediate factory component" ); + } + catch ( ComponentException ce ) + { + // expect + } + + // immediate is default false if factory is defined + final ComponentMetadata cm20 = createComponentMetadata( null, "factory" ); + cm20.setService( createServiceMetadata( Boolean.FALSE ) ); + cm20.validate( logger ); + assertFalse( "Component with factory must be delayed", cm20.isImmediate() ); + + // immediate is false if factory is defined + final ComponentMetadata cm21 = createComponentMetadata( Boolean.FALSE, "factory" ); + cm21.setService( createServiceMetadata( Boolean.FALSE ) ); + cm21.validate( logger ); + assertFalse( "Component with factory must be delayed", cm21.isImmediate() ); + + // immediate is default false if factory is defined + final ComponentMetadata cm22 = createComponentMetadata( Boolean.TRUE, "factory" ); + cm22.setService( createServiceMetadata( Boolean.FALSE ) ); + try + { + cm22.validate( logger ); + fail( "Expect validation failure for immediate factory component" ); + } + catch ( ComponentException ce ) + { + // expect + } + + // immediate is default false if factory is defined + final ComponentMetadata cm30 = createComponentMetadata( null, "factory" ); + cm30.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm30.validate( logger ); + fail( "Expect validation failure for factory component with service factory" ); + } + catch ( ComponentException ce ) + { + // expect + } + + // immediate is false if factory is defined + final ComponentMetadata cm31 = createComponentMetadata( Boolean.FALSE, "factory" ); + cm31.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm31.validate( logger ); + fail( "Expect validation failure for factory component with service factory" ); + } + catch ( ComponentException ce ) + { + // expect + } + + // immediate is default false if factory is defined + final ComponentMetadata cm32 = createComponentMetadata( Boolean.TRUE, "factory" ); + cm32.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm32.validate( logger ); + fail( "Expect validation failure for immediate factory component with service factory" ); + } + catch ( ComponentException ce ) + { + // expect + } + + } + + + public void test_component_no_name_ds10() + { + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.setName( null ); + try + { + cm1.validate( logger ); + fail( "Expected validation failure for DS 1.0 component without name" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_component_no_name_ds11() + { + final ComponentMetadata cm1 = createComponentMetadata11( Boolean.TRUE, null ); + cm1.setName( null ); + cm1.validate( logger ); + assertEquals( "Expected name to equal implementation class name", cm1.getImplementationClassName(), + cm1.getName() ); + } + + + public void test_component_activate_ds10() + { + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Activate method name", "activate", cm1.getActivate() ); + assertFalse( "Activate method expected to not be declared", cm1.isActivateDeclared() ); + + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.setActivate( "someMethod" ); + failDS10Validation( cm2, "activate", logger ); + } + + + public void test_component_activate_ds11() + { + final ComponentMetadata cm1 = createComponentMetadata11( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Activate method name", "activate", cm1.getActivate() ); + assertFalse( "Activate method expected to not be declared", cm1.isActivateDeclared() ); + + final ComponentMetadata cm2 = createComponentMetadata11( Boolean.TRUE, null ); + cm2.setActivate( "someMethod" ); + cm2.validate( logger ); + assertEquals( "Activate method name", "someMethod", cm2.getActivate() ); + assertTrue( "Activate method expected to be declared", cm2.isActivateDeclared() ); + } + + + public void test_component_deactivate_ds10() + { + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Deactivate method name", "deactivate", cm1.getDeactivate() ); + assertFalse( "Deactivate method expected to not be declared", cm1.isDeactivateDeclared() ); + + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.setDeactivate( "someMethod" ); + failDS10Validation( cm2, "deactivate", logger ); + } + + + public void test_component_deactivate_ds11() + { + final ComponentMetadata cm1 = createComponentMetadata11( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Deactivate method name", "deactivate", cm1.getDeactivate() ); + assertFalse( "Deactivate method expected to not be declared", cm1.isDeactivateDeclared() ); + + final ComponentMetadata cm2 = createComponentMetadata11( Boolean.TRUE, null ); + cm2.setDeactivate( "someMethod" ); + cm2.validate( logger ); + assertEquals( "Deactivate method name", "someMethod", cm2.getDeactivate() ); + assertTrue( "Deactivate method expected to be declared", cm2.isDeactivateDeclared() ); + } + + + public void test_component_modified_ds10() + { + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.validate( logger ); + assertNull( "Modified method name", cm1.getModified() ); + + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.setModified( "someName" ); + failDS10Validation( cm2, "modified", logger ); + } + + + public void test_component_modified_ds11() + { + final ComponentMetadata cm1 = createComponentMetadata11( Boolean.TRUE, null ); + cm1.validate( logger ); + assertNull( "Modified method name", cm1.getModified() ); + + final ComponentMetadata cm2 = createComponentMetadata11( Boolean.TRUE, null ); + cm2.setModified( "someMethod" ); + cm2.validate( logger ); + assertEquals( "Modified method name", "someMethod", cm2.getModified() ); + } + + + public void test_component_configuration_policy_ds10() + { + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Configuration policy", ComponentMetadata.CONFIGURATION_POLICY_OPTIONAL, + cm1.getConfigurationPolicy() ); + + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_IGNORE ); + failDS10Validation( cm2, "configuration-policy", logger ); + + final ComponentMetadata cm3 = createComponentMetadata( Boolean.TRUE, null ); + cm3.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_OPTIONAL ); + failDS10Validation( cm3, "configuration-policy", logger ); + + final ComponentMetadata cm4 = createComponentMetadata( Boolean.TRUE, null ); + cm4.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_REQUIRE ); + failDS10Validation( cm4, "configuration-policy", logger ); + + final ComponentMetadata cm5 = createComponentMetadata( Boolean.TRUE, null ); + cm5.setConfigurationPolicy( "undefined" ); + failDS10Validation( cm5, "configuration-policy", logger ); + } + + + public void test_component_configuration_policy_ds11() + { + final ComponentMetadata cm1 = createComponentMetadata11( Boolean.TRUE, null ); + cm1.validate( logger ); + assertEquals( "Configuration policy", ComponentMetadata.CONFIGURATION_POLICY_OPTIONAL, + cm1.getConfigurationPolicy() ); + + final ComponentMetadata cm2 = createComponentMetadata11( Boolean.TRUE, null ); + cm2.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_IGNORE ); + cm2.validate( logger ); + assertEquals( "Configuration policy", ComponentMetadata.CONFIGURATION_POLICY_IGNORE, + cm2.getConfigurationPolicy() ); + + final ComponentMetadata cm3 = createComponentMetadata11( Boolean.TRUE, null ); + cm3.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_OPTIONAL ); + cm3.validate( logger ); + assertEquals( "Configuration policy", ComponentMetadata.CONFIGURATION_POLICY_OPTIONAL, + cm3.getConfigurationPolicy() ); + + final ComponentMetadata cm4 = createComponentMetadata11( Boolean.TRUE, null ); + cm4.setConfigurationPolicy( ComponentMetadata.CONFIGURATION_POLICY_REQUIRE ); + cm4.validate( logger ); + assertEquals( "Configuration policy", ComponentMetadata.CONFIGURATION_POLICY_REQUIRE, + cm4.getConfigurationPolicy() ); + + final ComponentMetadata cm5 = createComponentMetadata11( Boolean.TRUE, null ); + cm5.setConfigurationPolicy( "undefined" ); + try + { + cm5.validate( logger ); + fail( "Expected validation failure due to undefined configuration policy" ); + } + catch ( ComponentException ce ) + { + // expected due to undefned configuration policy + } + } + + + public void test_reference_valid() + { + // two references, should validate + final ComponentMetadata cm1 = createComponentMetadata( Boolean.TRUE, null ); + cm1.addDependency( createReferenceMetadata( "name1" ) ); + cm1.addDependency( createReferenceMetadata( "name2" ) ); + cm1.validate( logger ); + } + + + public void test_reference_duplicate_name() + { + // two references with same name, must warn + final ComponentMetadata cm2 = createComponentMetadata( Boolean.TRUE, null ); + cm2.addDependency( createReferenceMetadata( "name1" ) ); + cm2.addDependency( createReferenceMetadata( "name1" ) ); + try + { + cm2.validate( logger ); + fail( "Expect validation failure for duplicate reference name" ); + } + catch ( ComponentException ee ) + { + //expected + } + } + + + public void test_reference_no_name_ds10() + { + // un-named reference, illegal for pre DS 1.1 + final ComponentMetadata cm3 = createComponentMetadata( Boolean.TRUE, null ); + cm3.addDependency( createReferenceMetadata( null ) ); + try + { + cm3.validate( logger ); + fail( "Expect validation failure for DS 1.0 reference without name" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_reference_no_name_ds11() + { + // un-named reference, illegal for DS 1.1 + final ComponentMetadata cm4 = createComponentMetadata11( Boolean.TRUE, null ); + final ReferenceMetadata rm4 = createReferenceMetadata( null ); + cm4.addDependency( rm4 ); + cm4.validate( logger ); + assertEquals( "Reference name defaults to interface", rm4.getInterface(), rm4.getName() ); + } + + + public void test_reference_updated_ds10() + { + // updated method ignored for DS 1.0 + final ReferenceMetadata rm3 = createReferenceMetadata( "test" ); + rm3.setUpdated( "my_updated_method" ); + final ComponentMetadata cm3 = createComponentMetadata( Boolean.TRUE, null ); + cm3.addDependency( rm3 ); + + // according to DS 1.2 must fail validation (FELIX-3648) + failDS10Validation( cm3, "updated", logger ); + } + + + public void test_reference_updated_ds11() + { + // updated method ignored for DS 1.1 + final ReferenceMetadata rm3 = createReferenceMetadata( "test" ); + rm3.setUpdated( "my_updated_method" ); + final ComponentMetadata cm3 = createComponentMetadata11( Boolean.TRUE, null ); + cm3.addDependency( rm3 ); + + // according to DS 1.2 must fail validation (FELIX-3648) + failDS10Validation( cm3, "updated", logger ); + } + + + public void test_reference_updated_ds11_felix() + { + // updated method accepted for DS 1.1-felix + final ReferenceMetadata rm3 = createReferenceMetadata( "test" ); + rm3.setUpdated( "my_updated_method" ); + final ComponentMetadata cm3 = createComponentMetadata( DSVersion.DS11Felix, Boolean.TRUE, null ); + cm3.addDependency( rm3 ); + + // validates fine and logs no message + cm3.validate( logger ); + + assertEquals( "my_updated_method", rm3.getUpdated() ); + } + + + public void test_reference_updated_ds12() + { + // updated method accepted for DS 1.2 + final ReferenceMetadata rm3 = createReferenceMetadata( "test" ); + rm3.setUpdated( "my_updated_method" ); + final ComponentMetadata cm3 = createComponentMetadata( DSVersion.DS12, Boolean.TRUE, null ); + cm3.addDependency( rm3 ); + + // validates fine and logs no message + cm3.validate( logger ); + + assertEquals( "my_updated_method", rm3.getUpdated() ); + } + + + public void test_duplicate_implementation_ds10() + { + final ComponentMetadata cm = createComponentMetadata( Boolean.TRUE, null ); + cm.setImplementationClassName( "second.implementation.class" ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for duplicate implementation element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_implementation_ds11() + { + final ComponentMetadata cm = createComponentMetadata11( Boolean.TRUE, null ); + cm.setImplementationClassName( "second.implementation.class" ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for duplicate implementation element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_service_ds10() + { + final ComponentMetadata cm = createComponentMetadata( Boolean.TRUE, null ); + cm.setService( createServiceMetadata( Boolean.TRUE ) ); + cm.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for duplicate service element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_service_ds11() + { + final ComponentMetadata cm = createComponentMetadata11( Boolean.TRUE, null ); + cm.setService( createServiceMetadata( Boolean.TRUE ) ); + cm.setService( createServiceMetadata( Boolean.TRUE ) ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for duplicate service element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_property_no_name_ds10() + { + final ComponentMetadata cm = createComponentMetadata( null, null ); + cm.addProperty( createPropertyMetadata( null, null, "" ) ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for missing property name" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_property_no_name_ds11() + { + final ComponentMetadata cm = createComponentMetadata11( null, null ); + cm.addProperty( createPropertyMetadata( null, null, "" ) ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for missing property name" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_property_char_ds10() throws ComponentException + { + final ComponentMetadata cm = createComponentMetadata( null, null ); + PropertyMetadata prop = createPropertyMetadata( "x", "Char", Integer.toString( 'x' ) ); + cm.addProperty( prop ); + cm.validate( logger ); + assertTrue( prop.getValue() instanceof Character ); + assertEquals( new Character( 'x' ), prop.getValue() ); + } + + + public void test_property_char_ds11() + { + final ComponentMetadata cm = createComponentMetadata11( null, null ); + cm.addProperty( createPropertyMetadata( "x", "Char", "x" ) ); + try + { + cm.validate( logger ); + fail( "Expect validation failure for illegal property type Char" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_property_non_character() + { + final ComponentMetadata cm = createComponentMetadata( null, null ); + + assertProperty( "String", "Ein String", cm ); + assertProperty( "Double", new Double( 2.5 ), cm ); + assertProperty( "Float", new Float( 2.5 ), cm ); + assertProperty( "Long", new Long( 2 ), cm ); + assertProperty( "Integer", new Integer( 2 ), cm ); + assertProperty( "Short", new Short( ( short ) 2 ), cm ); + assertProperty( "Byte", new Byte( ( byte ) 2 ), cm ); + assertProperty( "Boolean", Boolean.TRUE, cm ); + + assertPropertyFail( "Double", "x", cm ); + assertPropertyFail( "Float", "x", cm ); + assertPropertyFail( "Long", "x", cm ); + assertPropertyFail( "Integer", "x", cm ); + assertPropertyFail( "Short", "x", cm ); + assertPropertyFail( "Byte", "x", cm ); + } + + + public void test_property_array_non_character() + { + final ComponentMetadata cm = createComponentMetadata( null, null ); + assertPropertyArray( "String", "Ein String", cm ); + assertPropertyArray( "Double", new Double( 2.5 ), cm ); + assertPropertyArray( "Float", new Float( 2.5 ), cm ); + assertPropertyArray( "Long", new Long( 2 ), cm ); + assertPropertyArray( "Integer", new Integer( 2 ), cm ); + assertPropertyArray( "Short", new Short( ( short ) 2 ), cm ); + assertPropertyArray( "Byte", new Byte( ( byte ) 2 ), cm ); + assertPropertyArray( "Boolean", Boolean.TRUE, cm ); + + assertPropertyArrayFail( "Double", "x", cm ); + assertPropertyArrayFail( "Float", "x", cm ); + assertPropertyArrayFail( "Long", "x", cm ); + assertPropertyArrayFail( "Integer", "x", cm ); + assertPropertyArrayFail( "Short", "x", cm ); + assertPropertyArrayFail( "Byte", "x", cm ); + } + + + public void test_property_character_ds10() + { + final ComponentMetadata cm = createComponentMetadata( null, null ); + try + { + createPropertyMetadata( "x", "Character", Integer.toString( 'x' ) ).validate( cm ); + fail( "Expect validation failure for illegal property type Character" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + public void test_configuration_pid_use_ds12() + { + ComponentMetadata cm = createComponentMetadata11( null, null ); + try + { + cm.setConfigurationPid( new String[] {"configurationPid"} ); + cm.validate( logger ); + fail( "Expect validation failure for illegal configuration-pid usage in ds 1.1 namespace" ); + } + catch ( ComponentException ce ) + { + // expected + } + + cm = createComponentMetadata12( null, null ); + try + { + cm.setConfigurationPid( new String[] {"configurationPid"} ); + cm.validate( logger ); + } + catch ( ComponentException ce ) + { + ce.printStackTrace(); + fail( "Expect correct validation for legal configuration-pid usage in ds 1.2 or later namespace" ); + } + } + + public void test_get_configuration_pid_method() + { + doTest_get_configuration_pid_method(DSVersion.DS10); + doTest_get_configuration_pid_method(DSVersion.DS11); + doTest_get_configuration_pid_method(DSVersion.DS12); + } + + private void doTest_get_configuration_pid_method(DSVersion specVersion) + { + // Make sure that getConfigurationPid returns the default component name (implementation class name). + // We only do this kind of test if spec is greater than ds 1.0, because in ds 1.0, the component name is mandatory. + if ( specVersion.isDS11() ) + { + ComponentMetadata cm = new ComponentMetadata( specVersion ); + try + { + cm.setImplementationClassName("implementation.class"); + cm.setName( null ); + cm.validate( logger ); + } + catch ( ComponentException ce ) + { + fail( "Expect correct validation for unnamed component" ); + } + List<String> pid = cm.getConfigurationPid(); + assertFalse( "Expect non-null configuration pid when component name is not specified", pid.isEmpty() ); + assertEquals( "Expect configuration-pid to be equals to component implementation", + "implementation.class", pid.get( 0 ) ); + } + + // Make sure that getConfigurationPid returns the name of the component, if specified + ComponentMetadata cm = new ComponentMetadata( specVersion ); + try + { + cm.setImplementationClassName("implementation.class"); + cm.setName("my.component.name"); + cm.validate( logger ); + } + catch ( ComponentException ce ) + { + fail( "Expect correct validation for named component" ); + } + List<String> pid = cm.getConfigurationPid(); + assertFalse( "Expect non-null configuration pid when component name is not specified", pid.isEmpty() ); + assertEquals( "Expect configuration-pid to be equals to component name", + "my.component.name", pid.get( 0 ) ); + } + + public void test_property_character_ds11() throws ComponentException + { + final ComponentMetadata cm = createComponentMetadata11( null, null ); + PropertyMetadata prop = createPropertyMetadata( "x", "Character", Integer.toString( 'x' ) ); + cm.addProperty( prop ); + cm.validate( logger ); + assertTrue( prop.getValue() instanceof Character ); + assertEquals( new Character( 'x' ), prop.getValue() ); + } + + + //---------- Helper methods + + // method also used by XmlHandlerTest + static void failDS10Validation( final ComponentMetadata metadata, final String expectedValidationReason, + final MockLogger logger ) + { + try + { + metadata.validate( logger ); + fail( "Expected validation failure for Component " + metadata.getName() + " containing '" + + expectedValidationReason + "'" ); + } + catch ( ComponentException ce ) + { + assertTrue( + "Expected validation reason to contain '" + expectedValidationReason + "': actual: " + ce.getMessage(), + ce.getMessage().indexOf( expectedValidationReason ) >= 0 ); + } + } + + + // Creates Component Metadata for the given namespace + private ComponentMetadata createComponentMetadata( DSVersion dsVersion, Boolean immediate, String factory ) + { + ComponentMetadata meta = new ComponentMetadata( dsVersion ); + meta.setName( "place.holder" ); + meta.setImplementationClassName( "place.holder.implementation" ); + if ( immediate != null ) + { + meta.setImmediate( immediate.booleanValue() ); + } + if ( factory != null ) + { + meta.setFactoryIdentifier( factory ); + } + return meta; + } + + + // Creates DS 1.0 Component Metadata + private ComponentMetadata createComponentMetadata( Boolean immediate, String factory ) + { + return createComponentMetadata( DSVersion.DS10, immediate, factory ); + } + + + // Creates DS 1.1 Component Metadata + private ComponentMetadata createComponentMetadata11( Boolean immediate, String factory ) + { + return createComponentMetadata( DSVersion.DS11, immediate, factory ); + } + + // Creates DS 1.2 Component Metadata + private ComponentMetadata createComponentMetadata12( Boolean immediate, String factory ) + { + return createComponentMetadata( DSVersion.DS12, immediate, factory ); + } + + private ServiceMetadata createServiceMetadata( Boolean serviceFactory ) + { + ServiceMetadata meta = new ServiceMetadata(); + meta.addProvide( "place.holder.service" ); + if ( serviceFactory != null ) + { + meta.setServiceFactory( serviceFactory.booleanValue() ); + } + return meta; + } + + + private ReferenceMetadata createReferenceMetadata( String name ) + { + ReferenceMetadata meta = new ReferenceMetadata(); + meta.setName( name ); + meta.setInterface( "place.holder" ); + return meta; + } + + + private PropertyMetadata createPropertyMetadata( String propertyName, String type, String value ) + { + PropertyMetadata meta = new PropertyMetadata(); + if ( propertyName != null ) + { + meta.setName( propertyName ); + } + if ( type != null ) + { + meta.setType( type ); + } + if ( value != null ) + { + meta.setValue( value ); + } + return meta; + } + + + private void assertProperty( String type, Object value, ComponentMetadata cmeta ) + { + PropertyMetadata meta = createPropertyMetadata( "dummy", type, String.valueOf( value ) ); + meta.validate( cmeta ); + assertSame( value.getClass(), meta.getValue().getClass() ); + assertEquals( value, meta.getValue() ); + } + + + private void assertPropertyArray( String type, Object value, ComponentMetadata cmeta ) + { + PropertyMetadata meta = createPropertyMetadata( "dummy", type, null ); + meta.setValues( String.valueOf( value ) ); + meta.validate( cmeta ); + + Object propVal = meta.getValue(); + assertTrue( propVal.getClass().isArray() ); + assertPrimitiveType( value.getClass(), propVal.getClass().getComponentType() ); + assertEquals( 1, Array.getLength( propVal ) ); + assertEquals( value, Array.get( propVal, 0 ) ); + } + + + private void assertPropertyFail( String type, String value, ComponentMetadata cmeta ) + { + try + { + PropertyMetadata meta = createPropertyMetadata( "dummy", type, value ); + meta.validate( cmeta ); + fail( "Expected validation failure for " + type + "=" + value ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + private void assertPropertyArrayFail( String type, String value, ComponentMetadata cmeta ) + { + try + { + PropertyMetadata meta = createPropertyMetadata( "dummy", type, null ); + meta.setValues( value ); + meta.validate( cmeta ); + fail( "Expected validation failure for " + type + "=" + value ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + private void assertPrimitiveType( final Class expectedBoxClass, final Class actualClass ) + { + if ( expectedBoxClass == String.class ) + { + assertEquals( expectedBoxClass, actualClass ); + } + else if ( expectedBoxClass == Double.class ) + { + assertEquals( Double.TYPE, actualClass ); + } + else if ( expectedBoxClass == Float.class ) + { + assertEquals( Float.TYPE, actualClass ); + } + else if ( expectedBoxClass == Long.class ) + { + assertEquals( Long.TYPE, actualClass ); + } + else if ( expectedBoxClass == Integer.class ) + { + assertEquals( Integer.TYPE, actualClass ); + } + else if ( expectedBoxClass == Short.class ) + { + assertEquals( Short.TYPE, actualClass ); + } + else if ( expectedBoxClass == Byte.class ) + { + assertEquals( Byte.TYPE, actualClass ); + } + else if ( expectedBoxClass == Boolean.class ) + { + assertEquals( Boolean.TYPE, actualClass ); + } + else + { + fail( "Unexpected box class " + expectedBoxClass ); + } + } +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/XmlHandlerTest.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/XmlHandlerTest.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/XmlHandlerTest.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/XmlHandlerTest.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,480 @@ +/* + * 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.scr.impl.metadata; + + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.StringReader; +import java.util.Iterator; +import java.util.List; + +import junit.framework.TestCase; + +import org.apache.felix.scr.impl.MockBundle; +import org.apache.felix.scr.impl.MockLogger; +import org.apache.felix.scr.impl.parser.KXml2SAXParser; +import org.apache.felix.scr.impl.parser.ParseException; +import org.osgi.service.component.ComponentException; +import org.xmlpull.v1.XmlPullParserException; + + +public class XmlHandlerTest extends TestCase +{ + private MockLogger logger; + + + protected void setUp() throws Exception + { + super.setUp(); + + logger = new MockLogger(); + } + + + public void test_unclosed_elements() throws Exception + { + try + { + readMetadataFromString( "<component name=\"n\"><implementation class=\"n\" /><component name=\"x\">" ); + fail( "ParseException expected for unclosed elements" ); + } + catch ( ParseException pe ) + { + // exptected + } + } + + + public void test_no_opening_element() throws Exception + { + try + { + readMetadataFromString( "</component>" ); + fail( "Exception expected for element without opening element" ); + } + catch ( Exception p ) + { + // exptected + } + } + + + public void test_interleaved_elements() throws Exception + { + try + { + readMetadataFromString( "<component name=\"n\" ><implementation class=\"n\"></component></implementation>" ); + fail( "Exception expected for interleaved elements" ); + } + catch ( Exception p ) + { + // exptected + } + } + + + public void test_namespace_1_0_0() throws Exception + { + final List metadataList = readMetadataFromString( "<scr:component xmlns:scr=\"http://www.osgi.org/xmlns/scr/v1.0.0\"; name=\"n\" ><implementation class=\"n\"/></scr:component>" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.0.0", DSVersion.DS10, metadata.getDSVersion() ); + } + + + public void test_namespace_1_1_0() throws Exception + { + final List metadataList = readMetadataFromString( "<scr:component xmlns:scr=\"http://www.osgi.org/xmlns/scr/v1.1.0\"; name=\"n\" ><implementation class=\"n\"/></scr:component>" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.1.0", DSVersion.DS11, metadata.getDSVersion() ); + } + + + public void test_namespace_1_1_0_felix() throws Exception + { + final List metadataList = readMetadataFromString( "<scr:component xmlns:scr=\"http://felix.apache.org/xmlns/scr/v1.1.0-felix\"; name=\"n\" ><implementation class=\"n\"/></scr:component>" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.1.0-felix", DSVersion.DS11Felix, metadata.getDSVersion() ); + } + + + public void test_namespace_1_2_0() throws Exception + { + final List metadataList = readMetadataFromString( "<scr:component xmlns:scr=\"http://www.osgi.org/xmlns/scr/v1.2.0\"; name=\"n\" ><implementation class=\"n\"/></scr:component>" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.2.0", DSVersion.DS12, metadata.getDSVersion() ); + } + + + public void test_namespace_1_2_0_felix() throws Exception + { + final List metadataList = readMetadataFromString( "<scr:component xmlns:scr=\"http://felix.apache.org/xmlns/scr/v1.2.0-felix\"; name=\"n\" ><implementation class=\"n\"/></scr:component>" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.2.0-felix", DSVersion.DS12Felix, metadata.getDSVersion() ); + } + + + public void test_namespace_unknown() throws Exception + { + final List metadataList = readMetadataFromString( "<components xmlns:scr=\"http://www.osgi.org/xmlns/scr/v1.1.0-felix\";><scr:component name=\"n\" ><implementation class=\"n\"/></scr:component></components>" ); + assertTrue( "No Descriptor expected", metadataList.isEmpty() ); + } + + + public void test_no_namespace() throws Exception + { + final List metadataList = readMetadata( "/components_no_namespace.xml" ); + assertEquals( "1 Descriptor expected", 1, metadataList.size() ); + + final ComponentMetadata metadata = ( ComponentMetadata ) metadataList.get( 0 ); + assertEquals( "Expect NS 1.0.0", DSVersion.DS10, metadata.getDSVersion() ); + } + + + public void test_component_attributes_11() throws Exception + { + final List metadataList10 = readMetadata( "/components_activate_10.xml" ); + assertEquals( "Component Descriptors", 4, metadataList10.size() ); + ComponentMetadataTest.failDS10Validation( ( ComponentMetadata ) metadataList10.get( 0 ), "activate", logger ); + ComponentMetadataTest.failDS10Validation( ( ComponentMetadata ) metadataList10.get( 1 ), "deactivate", logger ); + ComponentMetadataTest.failDS10Validation( ( ComponentMetadata ) metadataList10.get( 2 ), "modified", logger ); + ComponentMetadataTest.failDS10Validation( ( ComponentMetadata ) metadataList10.get( 3 ), + "configuration-policy", logger ); + + final List metadataList11 = readMetadata( "/components_activate_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + cm11.validate( logger ); + assertEquals( "DS Version 1.1", DSVersion.DS11, cm11.getDSVersion() ); + assertEquals( "Expected Activate Method set", "myactivate", cm11.getActivate() ); + assertTrue( "Activate method expected to be declared", cm11.isActivateDeclared() ); + assertEquals( "Expected Deactivate Method set", "mydeactivate", cm11.getDeactivate() ); + assertTrue( "Activate method expected to be declared", cm11.isDeactivateDeclared() ); + assertEquals( "Expected Modified Method set", "mymodified", cm11.getModified() ); + assertEquals( "Expected Configuration Policy set", ComponentMetadata.CONFIGURATION_POLICY_IGNORE, + cm11.getConfigurationPolicy() ); + } + + + public void test_component_no_name() throws Exception + { + final List metadataList10 = readMetadata( "/components_anonymous_10.xml" ); + assertEquals( "Component Descriptors", 1, metadataList10.size() ); + final ComponentMetadata cm10 = ( ComponentMetadata ) metadataList10.get( 0 ); + try + { + cm10.validate( logger ); + fail( "Expected validation failure for component without name" ); + } + catch ( ComponentException ce ) + { + // expected !! + } + + final List metadataList11 = readMetadata( "/components_anonymous_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + cm11.validate( logger ); + assertEquals( "Expected name equals class", cm11.getImplementationClassName(), cm11.getName() ); + } + + + public void test_reference_no_name() throws Exception + { + final List metadataList10 = readMetadata( "/components_anonymous_10.xml" ); + assertEquals( "Component Descriptors", 1, metadataList10.size() ); + final ComponentMetadata cm10 = ( ComponentMetadata ) metadataList10.get( 0 ); + try + { + cm10.validate( logger ); + fail( "Expected validation failure for component without name" ); + } + catch ( ComponentException ce ) + { + // expected !! + } + + final List metadataList11 = readMetadata( "/components_anonymous_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + cm11.validate( logger ); + assertEquals( "Expected name equals class", cm11.getImplementationClassName(), cm11.getName() ); + } + + + public void test_all_elements_10() throws Exception + { + final List metadataList10 = readMetadata( "/components_all_elements_10.xml" ); + assertEquals( "Component Descriptors", 1, metadataList10.size() ); + final ComponentMetadata cm10 = ( ComponentMetadata ) metadataList10.get( 0 ); + + // dont validate this, we test the raw reading + + // ds namespace + assertEquals( "DS Version 1.0", DSVersion.DS10, cm10.getDSVersion() ); + assertFalse( "DS Version 1.0", cm10.getDSVersion().isDS11() ); + + // base component attributes + assertEquals( "component name", true, cm10.isEnabled() ); + assertEquals( "component name", "components.all.name", cm10.getName() ); + assertEquals( "component name", "components.all.factory", cm10.getFactoryIdentifier() ); + assertEquals( "component name", true, cm10.isFactory() ); + assertEquals( "component name", true, cm10.isImmediate() ); + + // ds 1.1 elements + assertEquals( "activate method", "myactivate", cm10.getActivate() ); + assertEquals( "deactivate method", "mydeactivate", cm10.getDeactivate() ); + assertTrue( "Activate method expected to be declared", cm10.isActivateDeclared() ); + assertEquals( "modified method", "mymodified", cm10.getModified() ); + assertTrue( "Deactivate method expected to be declared", cm10.isDeactivateDeclared() ); + assertEquals( "configuration policy", "ignore", cm10.getConfigurationPolicy() ); + + // from the implementation element + assertEquals( "component name", "components.all.impl", cm10.getImplementationClassName() ); + + // property setting + final PropertyMetadata prop = getPropertyMetadata( cm10, "prop" ); + prop.validate( cm10 ); // property value requires validation + assertNotNull( "prop exists", prop ); + assertEquals( "prop type", "Integer", prop.getType() ); + assertEquals( "prop value", 1234, ( ( Integer ) prop.getValue() ).intValue() ); + + final PropertyMetadata file_property = getPropertyMetadata( cm10, "file.property" ); + file_property.validate( cm10 ); // property value requires validation + assertNotNull( "file.property exists", file_property ); + assertEquals( "file.property type", "String", file_property.getType() ); + assertEquals( "file.property value", "Property from File", file_property.getValue() ); + + // service setup + final ServiceMetadata sm = cm10.getServiceMetadata(); + sm.validate( cm10 ); // service metadata requires validation to set scope properly + assertNotNull( "service", sm ); + assertEquals( "servicefactory", ServiceMetadata.Scope.bundle, sm.getScope() ); + assertEquals( "1 interface", 1, sm.getProvides().length ); + assertEquals( "service interface", "components.all.service", sm.getProvides()[0] ); + + // references - basic + final ReferenceMetadata rm = getReference( cm10, "ref.name" ); + assertNotNull( "refeference ref.name", rm ); + assertEquals( "ref.name name", "ref.name", rm.getName() ); + assertEquals( "ref.name interface", "ref.service", rm.getInterface() ); + assertEquals( "ref.name cardinality", "0..n", rm.getCardinality() ); + assertEquals( "ref.name policy", "dynamic", rm.getPolicy() ); + assertEquals( "ref.name target", "ref.target", rm.getTarget() ); + assertEquals( "ref.name target prop name", "ref.name.target", rm.getTargetPropertyName() ); + assertEquals( "ref.name bind method", "ref_bind", rm.getBind() ); + assertEquals( "ref.name undbind method", "ref_unbind", rm.getUnbind() ); + + // references - cardinality side properties (isOptional, isMultiple) + final ReferenceMetadata rm01 = getReference( cm10, "ref.01" ); + assertNotNull( "refeference ref.01", rm01 ); + assertEquals( "ref.01 cardinality", "0..1", rm01.getCardinality() ); + final ReferenceMetadata rm11 = getReference( cm10, "ref.11" ); + assertNotNull( "refeference ref.11", rm11 ); + assertEquals( "ref.11 cardinality", "1..1", rm11.getCardinality() ); + final ReferenceMetadata rm0n = getReference( cm10, "ref.0n" ); + assertNotNull( "refeference ref.0n", rm0n ); + assertEquals( "ref.0n cardinality", "0..n", rm0n.getCardinality() ); + final ReferenceMetadata rm1n = getReference( cm10, "ref.1n" ); + assertNotNull( "refeference ref.1n", rm1n ); + assertEquals( "ref.1n cardinality", "1..n", rm1n.getCardinality() ); + } + + + public void test_duplicate_implementation_class_10() throws Exception + { + final List metadataList10 = readMetadata( "/components_duplicate_implementation_10.xml" ); + assertEquals( "Component Descriptors", 1, metadataList10.size() ); + final ComponentMetadata cm10 = ( ComponentMetadata ) metadataList10.get( 0 ); + try + { + cm10.validate( logger ); + fail( "Expect validation failure for duplicate implementation element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_implementation_class_11() throws Exception + { + final List metadataList11 = readMetadata( "/components_duplicate_implementation_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + try + { + cm11.validate( logger ); + fail( "Expect validation failure for duplicate implementation element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_service_10() throws Exception + { + final List metadataList10 = readMetadata( "/components_duplicate_service_10.xml" ); + assertEquals( "Component Descriptors", 1, metadataList10.size() ); + final ComponentMetadata cm10 = ( ComponentMetadata ) metadataList10.get( 0 ); + try + { + cm10.validate( logger ); + fail( "Expect validation failure for duplicate service element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + public void test_duplicate_service_11() throws Exception + { + final List metadataList11 = readMetadata( "/components_duplicate_service_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + try + { + cm11.validate( logger ); + fail( "Expect validation failure for duplicate service element" ); + } + catch ( ComponentException ce ) + { + // expected + } + } + + + //---------- helper + + private List readMetadata( final Reader reader ) throws IOException, ComponentException, XmlPullParserException, + Exception + { + + try + { + final KXml2SAXParser parser = new KXml2SAXParser( reader ); + + XmlHandler handler = new XmlHandler( new MockBundle(), logger, false, false ); + parser.parseXML( handler ); + + return handler.getComponentMetadataList(); + } + finally + { + try + { + reader.close(); + } + catch ( IOException ignore ) + { + } + } + } + + + private List readMetadata( String filename ) throws IOException, ComponentException, XmlPullParserException, + Exception + { + BufferedReader in = new BufferedReader( new InputStreamReader( getClass().getResourceAsStream( filename ), + "UTF-8" ) ); + return readMetadata( in ); + } + + + private List readMetadataFromString( final String source ) throws IOException, ComponentException, + XmlPullParserException, Exception + { + return readMetadata( new StringReader( source ) ); + } + + + private ReferenceMetadata getReference( final ComponentMetadata cm, final String name ) + { + List rmlist = cm.getDependencies(); + for ( Iterator rmi = rmlist.iterator(); rmi.hasNext(); ) + { + ReferenceMetadata rm = ( ReferenceMetadata ) rmi.next(); + if ( name.equals( rm.getName() ) ) + { + return rm; + } + } + + // none found + return null; + } + + + private PropertyMetadata getPropertyMetadata( final ComponentMetadata cm, final String name ) + { + List pmlist = cm.getPropertyMetaData(); + for ( Iterator pmi = pmlist.iterator(); pmi.hasNext(); ) + { + PropertyMetadata pm = ( PropertyMetadata ) pmi.next(); + if ( name.equals( pm.getName() ) ) + { + return pm; + } + } + + // none found + return null; + } + + public void test_properties_11() throws Exception + { + final List metadataList11 = readMetadata( "/components_properties_11.xml" ); + assertEquals( "Component Descriptors", 1, metadataList11.size() ); + final ComponentMetadata cm11 = ( ComponentMetadata ) metadataList11.get( 0 ); + + // dont validate this, we test the raw reading + + // ds namespace + assertEquals( "DS Version 1.1", DSVersion.DS11, cm11.getDSVersion() ); + assertTrue( "DS Version 1.1", cm11.getDSVersion().isDS11() ); + + assertEquals( "component name", "DummyClass", cm11.getName() ); + assertEquals( "component name", "DummyClass", cm11.getImplementationClassName() ); + + // property setting + final PropertyMetadata prop = getPropertyMetadata( cm11, "char_array_property" ); + assertNotNull( "prop exists", prop ); + assertEquals( "prop type", "Character", prop.getType() ); + prop.validate( cm11 ); // property value conversion requires validation + Object value = prop.getValue(); + assertTrue( "prop array", value instanceof char[] ); + char[] chars = ( char[] ) value; + assertEquals( "prop number of values", 2, chars.length ); + assertEquals( "prop value 0", 'A', chars[0] ); + assertEquals( "prop value 1", 'B', chars[1] ); + } + +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/AcceptMethod.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/AcceptMethod.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/AcceptMethod.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/AcceptMethod.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,71 @@ +/* + * 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.scr.impl.metadata.instances; + + +/** + * The <code>AcceptMethod</code> class provides methods, which are used to + * test the ReflectionHelper.acceptMethod() method. + */ +public class AcceptMethod +{ + + public void public_void() + { + } + + + public String public_string() + { + return ""; + } + + + protected void protected_void() + { + } + + + protected String protected_string() + { + return ""; + } + + + private void private_void() + { + } + + + private String private_string() + { + return ""; + } + + + void package_void() + { + } + + + String package_string() + { + return ""; + } +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/BaseObject.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/BaseObject.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/BaseObject.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/BaseObject.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,113 @@ +/* + * 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.scr.impl.metadata.instances; + + +import java.util.Map; + +import org.osgi.framework.BundleContext; +import org.osgi.service.component.ComponentContext; + + +/** + * The <code>BaseObject</code> is a base class providing a number of methods + * to check. All methods take various combinations of arguments and return + * a single helper string to indicate what method has been called. + */ +public class BaseObject +{ + + private String m_calledMethod; + + + public String getCalledMethod() + { + String cm = m_calledMethod; + m_calledMethod = null; + return cm; + } + + + protected void setCalledMethod(String calledMethod) { + m_calledMethod = calledMethod; + } + + private void activate_no_arg() + { + setCalledMethod( "activate_no_arg" ); + } + + + protected void activate_comp( ComponentContext ctx ) + { + setCalledMethod( "activate_comp" ); + } + + + void activate_comp_bundle( ComponentContext ctx, BundleContext bundle ) + { + setCalledMethod( "activate_comp_bundle" ); + } + + + protected void activate_suitable( ComponentContext ctx ) + { + setCalledMethod( "activate_suitable" ); + } + + //precedence rules + + private void activate_precedence_1( ComponentContext ctx ) + { + setCalledMethod("activate_precedence_1_comp"); + } + + void activate_precedence_1( BundleContext bundleContext ) + { + setCalledMethod("activate_precedence_1_bundleContext"); + } + + protected void activate_precedence_1( Map map) + { + setCalledMethod("activate_precedence_1_map"); + } + + private void activate_precedence_2( Map map ) + { + setCalledMethod("activate_precedence_2_map"); + } + + void activate_precedence_2( ComponentContext ctx, BundleContext bundle ) + { + setCalledMethod("activate_precedence_2_comp_bundleContext"); + } + + protected void activate_precedence_2() + { + setCalledMethod("activate_precedence_2_empty"); + } + + + public @interface Ann1 { } + public @interface Ann2 { } + + void activate_13_2_annotations(ComponentContext cc, Ann1 a1, BundleContext c, Ann2 a2, Map<String, Object> map, ComponentContext cc2) { + setCalledMethod("activate_13_2_annotations"); + } +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level1Object.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level1Object.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level1Object.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level1Object.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,41 @@ +/* + * 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.scr.impl.metadata.instances; + + +import java.util.Map; + +import org.osgi.framework.BundleContext; + + +public class Level1Object extends BaseObject +{ + + private void activate_level1_bundle( BundleContext ctx ) + { + setCalledMethod("activate_level1_bundle"); + } + + + protected void activate_level1_map( Map props ) + { + setCalledMethod("activate_level1_map"); + } + +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level3Object.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level3Object.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level3Object.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances/Level3Object.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,49 @@ +/* + * 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.scr.impl.metadata.instances; + + +import java.util.Map; + +import org.apache.felix.scr.impl.metadata.instances2.Level2Object; +import org.osgi.service.component.ComponentContext; + + +public class Level3Object extends Level2Object +{ + + private void activate_comp_map( ComponentContext ctx, Map map ) + { + setCalledMethod("activate_comp_map"); + } + + + // this method should not be found, since the method taking a + // Map has higher precedence + public void activate_collision() + { + setCalledMethod("not_expected_to_be_found"); + } + + + public void activate_collision( Map map ) + { + setCalledMethod("activate_collision"); + } +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances2/Level2Object.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances2/Level2Object.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances2/Level2Object.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/metadata/instances2/Level2Object.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,65 @@ +/* + * 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.scr.impl.metadata.instances2; + + +import java.util.Map; + +import org.apache.felix.scr.impl.metadata.instances.Level1Object; +import org.osgi.service.component.ComponentContext; + + +public class Level2Object extends Level1Object +{ + + private void activate_comp_map( ComponentContext ctx, Map map ) + { + setCalledMethod( "activate_comp_map" ); + } + + + // this method should not be found, since the method taking a + // Map has higher precedence + public void activate_collision() + { + setCalledMethod( "not_expected_to_be_found" ); + } + + + public void activate_collision( Map map ) + { + setCalledMethod( "activate_collision" ); + } + + + private void activate_suitable( Map map ) + { + setCalledMethod( "activate_suitable" ); + } + + private void activate_comp_unsuitable( ComponentContext ctx ) + { + setCalledMethod( "activate_comp_unsuitable" ); + } + + protected void activate_comp_unsuitable( Map map ) + { + setCalledMethod( "activate_comp_unsuitable" ); + } +} Added: felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/runtime/ServiceComponentRuntimeImplTest.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/runtime/ServiceComponentRuntimeImplTest.java?rev=1689973&view=auto ============================================================================== --- felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/runtime/ServiceComponentRuntimeImplTest.java (added) +++ felix/sandbox/pderop/dependencymanager.ds/org.apache.felix.dependencymanager.ds/test/org/apache/felix/scr/impl/runtime/ServiceComponentRuntimeImplTest.java Wed Jul 8 22:10:14 2015 @@ -0,0 +1,119 @@ +/* + * 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.scr.impl.runtime; + +import java.lang.reflect.Method; +import java.util.Arrays; + +import junit.framework.TestCase; + +import org.mockito.Mockito; +import org.osgi.dto.DTO; +import org.osgi.framework.Bundle; +import org.osgi.framework.Constants; +import org.osgi.framework.ServiceReference; +import org.osgi.framework.dto.BundleDTO; +import org.osgi.framework.dto.ServiceReferenceDTO; + +public class ServiceComponentRuntimeImplTest extends TestCase +{ + + /* in case behavior is supposed to actually involve copying + public void testCopy() + { + ServiceComponentRuntimeImpl scr = new ServiceComponentRuntimeImpl(null, null); + assertEquals(1, scr.convert(1)); + assertEquals("foo", scr.convert("foo")); + equalCopy(new int[] {1, 2, 3}, scr); + equalCopy(new byte[] {1, 2, 3}, scr); + equalCopy(new String[] {"1", "2", "3"}, scr); + equalCopy(new Long[] {1l, 2l, 3l}, scr); + } + + private void equalCopy(Object o1, ServiceComponentRuntimeImpl scr) + { + Object o2 = scr.convert(o1); + assertEquals("expected same length", Array.getLength(o1), Array.getLength(o2)); + assertEquals("expceted same component type", o1.getClass().getComponentType(), o2.getClass().getComponentType()); + for (int i = 0; i < Array.getLength(o1); i++) + { + assertEquals("expected same value at " + i, Array.get(o1, i), Array.get(o2, i)); + } + + } + */ + + public void testNullBundleServiceReferenceDTO() throws Exception + { + ServiceReference<?> sr = Mockito.mock(ServiceReference.class); + Mockito.when(sr.getProperty(Constants.SERVICE_ID)).thenReturn(327L); + Mockito.when(sr.getPropertyKeys()).thenReturn(new String[] {}); + + ServiceComponentRuntimeImpl scr = new ServiceComponentRuntimeImpl(null, null); + Method m = scr.getClass().getDeclaredMethod("serviceReferenceToDTO", ServiceReference.class); + m.setAccessible(true); + ServiceReferenceDTO dto = (ServiceReferenceDTO) m.invoke(scr, sr); + assertEquals(-1, dto.bundle); + } + + public void testNullBundleServiceReferenceDTO2() throws Exception + { + Bundle b = Mockito.mock(Bundle.class); + Mockito.when(b.getBundleId()).thenReturn(42L); + + ServiceReference<?> sr = Mockito.mock(ServiceReference.class); + Mockito.when(sr.getProperty(Constants.SERVICE_ID)).thenReturn(327L); + Mockito.when(sr.getPropertyKeys()).thenReturn(new String[] {}); + Mockito.when(sr.getBundle()).thenReturn(b); + + ServiceComponentRuntimeImpl scr = new ServiceComponentRuntimeImpl(null, null); + Method m = scr.getClass().getDeclaredMethod("serviceReferenceToDTO", ServiceReference.class); + m.setAccessible(true); + ServiceReferenceDTO dto = (ServiceReferenceDTO) m.invoke(scr, sr); + assertEquals(42, dto.bundle); + } + + public void testConvert() + { + ServiceComponentRuntimeImpl scr = new ServiceComponentRuntimeImpl(null, null); + same("foo", scr); + same(Boolean.TRUE, scr); + same(1, scr); + same(1l, scr); + same(new ServiceReferenceDTO(), scr); + same( new String[] {"foo", "bar"}, scr); + same( new Boolean[] {true, false}, scr); + same( new Long[] {1l, 2l}, scr); + same( new DTO[] {new ServiceReferenceDTO(), new BundleDTO()}, scr); + equalsToString(new int[] {1, 2}, scr); + equalsToString(Arrays.asList(new int[] {1, 2}), scr); + equalsToString(Arrays.asList(new String[] {"foo", "bar"}), scr); + } + + private void equalsToString(Object o, ServiceComponentRuntimeImpl scr) + { + assertEquals(String.valueOf(o), scr.convert(o)); + } + + private void same(Object o, ServiceComponentRuntimeImpl scr) + { + assertSame(o, scr.convert(o)); + } + +}
