diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/pom.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/pom.xml
index c27cf16..ca65cf1 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/pom.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/pom.xml
@@ -1,4 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
index 7e5d145..20e2773 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
index 5ac64d3..5711222 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
index 7d18712..91c9f75 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
index eee88a2..5abe521 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
index 03016d3..c53570b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
index b9eda2d..a0e9e43 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
index 47f6ae5..700d9fe 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
index efec5f0..f1732ba 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
index c3ade01..84f9e36 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
index d230c2d..5c2c033 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
index f90460c..dccebaf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
index e31a24a..5e2b59a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
index f704138..62eb08d 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
index a4c4854..b9cec94 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
index eca0faa..55bf6bb 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
index 37c1a65..4ce1646 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
index ba526f5..a65e2dd 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
index 19bd528..82d307c 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
index 8ed22ec..037dad3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata-import-export.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata-import-export.xml
index 059c8b7..26a1407 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata-import-export.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata-import-export.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd 
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata.xml
index 6143ff9..d70c60b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/main/resources/metadata.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
index 1c93fa4..3ea95ca 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core;
 
 import ch.qos.logback.classic.Level;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestFilteredExport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestFilteredExport.java
index 09f3fca..bce5471 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestFilteredExport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestFilteredExport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestMultipleExport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestMultipleExport.java
index e7871b1..b9ca3a7 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestMultipleExport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestMultipleExport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalExport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalExport.java
index 2b3975e..b1716a3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalExport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalExport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalMultipleExport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalMultipleExport.java
index 40c0d5d..23afd48 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalMultipleExport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestOptionalMultipleExport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestSimpleExport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestSimpleExport.java
index a8af21b..49cad50 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestSimpleExport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/exporter/TestSimpleExport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedFilteredImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedFilteredImport.java
index fe15caf..2b4bdf7 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedFilteredImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedFilteredImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedMultipleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedMultipleImport.java
index 9fa1877..566c26a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedMultipleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedMultipleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalImport.java
index d1aafa9..0b3ba04 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalMultipleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalMultipleImport.java
index 18644b7..13c953b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalMultipleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedOptionalMultipleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedSimpleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedSimpleImport.java
index 8da4190..262de1b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedSimpleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestDelayedSimpleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestFilteredImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestFilteredImport.java
index e8dc250..e019877 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestFilteredImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestFilteredImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestMultipleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestMultipleImport.java
index 188df8a..7cdb91a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestMultipleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestMultipleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalImport.java
index 7d914d5..3d7d351 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalMultipleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalMultipleImport.java
index b36187c..d5259d8 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalMultipleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestOptionalMultipleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestSimpleImport.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestSimpleImport.java
index e958919..c97965a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestSimpleImport.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-import-export-test/src/test/java/org/apache/felix/ipojo/runtime/core/importer/TestSimpleImport.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/pom.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/pom.xml
index 06d1540..0148035 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/pom.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/pom.xml
@@ -1,4 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
index 7e5d145..20e2773 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
index 5ac64d3..5711222 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
index 7d18712..91c9f75 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
index eee88a2..5abe521 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
index 03016d3..c53570b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
index b9eda2d..a0e9e43 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
index 47f6ae5..700d9fe 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
index efec5f0..f1732ba 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
index 65295b7..f772059 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.components;
 
 import org.apache.felix.ipojo.runtime.core.services.CheckService;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
index 702899f..9c2f212 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.components;
 
 import org.apache.felix.ipojo.runtime.core.services.Service;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
index c3ade01..84f9e36 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
index d230c2d..5c2c033 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
index f90460c..dccebaf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
index e31a24a..5e2b59a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
index f704138..62eb08d 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
index a4c4854..b9cec94 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
index eca0faa..55bf6bb 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
index 37c1a65..4ce1646 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
index 7b85548..6ef60bf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.services;
 
 public interface Service {
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
index ba526f5..a65e2dd 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
index 19bd528..82d307c 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
index 8ed22ec..037dad3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata-instance.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata-instance.xml
index 9857648..90131d8 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata-instance.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata-instance.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata.xml
index 6143ff9..d70c60b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/main/resources/metadata.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
index 1c93fa4..3ea95ca 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core;
 
 import ch.qos.logback.classic.Level;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestInstanceScope.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestInstanceScope.java
index 9a3ce08..f9e09ba 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestInstanceScope.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestInstanceScope.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.instance;
 
 import org.apache.felix.ipojo.ComponentInstance;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestSimpleInstance.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestSimpleInstance.java
index b1f0ee0..d145404 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestSimpleInstance.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instance/TestSimpleInstance.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfigurableInstantiation.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfigurableInstantiation.java
index b55d8f1..a2411a1 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfigurableInstantiation.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfigurableInstantiation.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfiguration.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfiguration.java
index 4e757cb..a2be2c0 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfiguration.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestConfiguration.java
@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.felix.ipojo.runtime.core.instantiator;
 
 import org.apache.felix.ipojo.ComponentFactory;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestMultipleInstantiation.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestMultipleInstantiation.java
index be3f4fe..3aa511f 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestMultipleInstantiation.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestMultipleInstantiation.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalInstantiation.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalInstantiation.java
index 4829107..667d724 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalInstantiation.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalInstantiation.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalMultipleInstantiation.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalMultipleInstantiation.java
index 29eb2f6..0dd0c05 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalMultipleInstantiation.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestOptionalMultipleInstantiation.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestSimpleInstantiation.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestSimpleInstantiation.java
index ff18fb3..1310a64 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestSimpleInstantiation.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-instance-test/src/test/java/org/apache/felix/ipojo/runtime/core/instantiator/TestSimpleInstantiation.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/pom.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/pom.xml
index 643df52..18434a1 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/pom.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/pom.xml
@@ -1,4 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
index 7e5d145..20e2773 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
index 5ac64d3..5711222 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
index 7d18712..91c9f75 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
index eee88a2..5abe521 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
index 03016d3..c53570b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
index b9eda2d..a0e9e43 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
index 47f6ae5..700d9fe 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
index efec5f0..f1732ba 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
index c3ade01..84f9e36 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
index d230c2d..5c2c033 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
index f90460c..dccebaf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
index e31a24a..5e2b59a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
index f704138..62eb08d 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
index a4c4854..b9cec94 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
index eca0faa..55bf6bb 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
index 37c1a65..4ce1646 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
index ba526f5..a65e2dd 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
index 19bd528..82d307c 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
index 8ed22ec..037dad3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/resources/metadata.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/resources/metadata.xml
index fc4b9de..bd63765 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/resources/metadata.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/main/resources/metadata.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
index 1c93fa4..3ea95ca 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core;
 
 import ch.qos.logback.classic.Level;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/EmptyCompositeTest.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/EmptyCompositeTest.java
index f3e2e9d..ef86997 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/EmptyCompositeTest.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/EmptyCompositeTest.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/FactoryManagementTest.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/FactoryManagementTest.java
index 24c63e9..93402e7 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/FactoryManagementTest.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/FactoryManagementTest.java
@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.felix.ipojo.runtime.core;
 
 import org.apache.felix.ipojo.*;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRangeTest.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRangeTest.java
index 0a4d6b3..88363ee 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRangeTest.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRangeTest.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRegistryTest.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRegistryTest.java
index c7da5ae..6c41da3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRegistryTest.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-runtime-test/src/test/java/org/apache/felix/ipojo/runtime/core/ServiceRegistryTest.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/pom.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/pom.xml
index eb19703..b14d050 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/pom.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/pom.xml
@@ -1,4 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
index 7e5d145..20e2773 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/Baz2CheckProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
index 5ac64d3..5711222 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/BazProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
index 7d18712..91c9f75 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckProviderParentClass.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
index eee88a2..5abe521 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/CheckServiceProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
index 03016d3..c53570b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooBarProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
index b9eda2d..a0e9e43 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderType1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
index 47f6ae5..700d9fe 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
index efec5f0..f1732ba 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/FooProviderTypeDyn2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
index 65295b7..f772059 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceConsumer.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.components;
 
 import org.apache.felix.ipojo.runtime.core.services.CheckService;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
index 702899f..9c2f212 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/ServiceProvider.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.components;
 
 import org.apache.felix.ipojo.runtime.core.services.Service;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
index c3ade01..84f9e36 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TataProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
index d230c2d..5c2c033 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProvider.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
index f90460c..dccebaf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/components/TotoProviderGlue.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
index e31a24a..5e2b59a 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/A123/CheckService2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
index f704138..62eb08d 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BarService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
index a4c4854..b9cec94 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/BazService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
index eca0faa..55bf6bb 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/CheckService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
index 37c1a65..4ce1646 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/FooService.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
index 7b85548..6ef60bf 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Service.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core.services;
 
 public interface Service {
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
index ba526f5..a65e2dd 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tata.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
index 75ba4d3..8f10422 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Tota.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
index 8ed22ec..037dad3 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/java/org/apache/felix/ipojo/runtime/core/services/Toto.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata-providing.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata-providing.xml
index da0e7b3..a4cff41 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata-providing.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata-providing.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd 
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata.xml b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata.xml
index 6143ff9..d70c60b 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata.xml
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/main/resources/metadata.xml
@@ -1,3 +1,22 @@
+<!--
+  ~ 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.
+  -->
+
 <ipojo
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="org.apache.felix.ipojo http://felix.apache.org/ipojo/schemas/SNAPSHOT/core.xsd
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
index 1f6d57c..125f419 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/Common.java
@@ -1,3 +1,22 @@
+/*
+ * 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.runtime.core;
 
 import ch.qos.logback.classic.Level;
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/TestCompositeAPI.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/TestCompositeAPI.java
index 1effcb4..2bdfea2 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/TestCompositeAPI.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/TestCompositeAPI.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp0.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp0.java
index de6eb67..c8149db 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp0.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp0.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp1.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp1.java
index cec2ce8..62af8b7 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp1.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp1.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp2.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp2.java
index 4004301..f7e2f64 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp2.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp2.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp3.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp3.java
index 06f4ee4..904d61c 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp3.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp3.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp4.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp4.java
index eca3287..9982ae4 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp4.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp4.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp5.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp5.java
index fc2a6bc..5714a41 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp5.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp5.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp6.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp6.java
index de91e85..767c7f7 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp6.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp6.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp7.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp7.java
index d47fe48..f6389f4 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp7.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp7.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
diff --git a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp8.java b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp8.java
index 32c1402..0f34872 100644
--- a/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp8.java
+++ b/ipojo/runtime/composite-it/src/it/ipojo-composite-service-providing-test/src/test/java/org/apache/felix/ipojo/runtime/core/providing/TestComp8.java
@@ -1,4 +1,4 @@
-/* 
+/*
  * 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
