diff --git a/bundlerepository/src/test/resources/referral1_repository.xml b/bundlerepository/src/test/resources/referral1_repository.xml
index 26e640f..741f469 100644
--- a/bundlerepository/src/test/resources/referral1_repository.xml
+++ b/bundlerepository/src/test/resources/referral1_repository.xml
@@ -1,3 +1,21 @@
+<!--
+ 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.
+-->
 <repository lastmodified="20061215121044.644" name="referral1_repository">
     <referral depth="1" url="referred.xml" />
 
@@ -6,4 +24,4 @@
         uri="http://oscar-osgi.sf.net/obr2/telnetd/telnetd.jar"
         version="1.0.0" />
         
-</repository>
\ No newline at end of file
+</repository>
diff --git a/bundlerepository/src/test/resources/referred.xml b/bundlerepository/src/test/resources/referred.xml
index 19ad608..157be81 100644
--- a/bundlerepository/src/test/resources/referred.xml
+++ b/bundlerepository/src/test/resources/referred.xml
@@ -1,3 +1,21 @@
+<!--
+ 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.
+-->
 <repository lastmodified="20061215121044.644" name="referred">
 
     <resource id="99" presentationname="1_referredSample"
@@ -5,4 +23,4 @@
         uri="referredSample.jar"
         version="1.0.0" />
         
-</repository>
\ No newline at end of file
+</repository>
diff --git a/bundlerepository/src/test/resources/repo_for_mandatory.xml b/bundlerepository/src/test/resources/repo_for_mandatory.xml
index 96fd4b9..5bb3787 100644
--- a/bundlerepository/src/test/resources/repo_for_mandatory.xml
+++ b/bundlerepository/src/test/resources/repo_for_mandatory.xml
@@ -1,4 +1,22 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+ 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.
+-->
 <repository lastmodified="2010" name="repo_for_optional_resources">
 
     <resource id="res1">
diff --git a/bundlerepository/src/test/resources/repo_for_optional_resources.xml b/bundlerepository/src/test/resources/repo_for_optional_resources.xml
index b747a3e..2b5faca 100644
--- a/bundlerepository/src/test/resources/repo_for_optional_resources.xml
+++ b/bundlerepository/src/test/resources/repo_for_optional_resources.xml
@@ -1,4 +1,22 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+ 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.
+-->
 <repository lastmodified="2010" name="repo_for_optional_resources">
 
     <resource id="res1">
diff --git a/bundlerepository/src/test/resources/repo_for_resolvertest.xml b/bundlerepository/src/test/resources/repo_for_resolvertest.xml
index f343dfa..10686ad 100644
--- a/bundlerepository/src/test/resources/repo_for_resolvertest.xml
+++ b/bundlerepository/src/test/resources/repo_for_resolvertest.xml
@@ -1,4 +1,22 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+ 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.
+-->
 <repository lastmodified="20090306073223.859" name="MyRepository">
 
     <resource id="dummy/1.0.0.SNAPSHOT"
@@ -1030,4 +1048,4 @@
 			filter="(&amp;(package=org.xml.sax)(version&gt;=0.0.0))" multiple="false"
 			name="package" optional="true">Import package org.xml.sax</require>
 	</resource>
-</repository>
\ No newline at end of file
+</repository>
