diff --git a/serviceusermapper/pom.xml b/serviceusermapper/pom.xml
new file mode 100644
index 0000000..a52b6bb
--- /dev/null
+++ b/serviceusermapper/pom.xml
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+    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/maven-v4_0_0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.sling</groupId>
+        <artifactId>sling</artifactId>
+        <version>30</version>
+        <relativePath />
+    </parent>
+
+    <artifactId>org.apache.sling.serviceusermapper</artifactId>
+    <packaging>bundle</packaging>
+    <version>1.3.0</version>
+
+    <name>Apache Sling Service User Mapper</name>
+    <description>
+        Provides a service to map service names with
+        optional service information to user names to
+        be used to access repositories such as the JCR
+        repository or the Sling ResourceResolver.
+    </description>
+
+    <scm>
+        <connection>scm:svn:http://svn.apache.org/repos/asf/sling/tags/org.apache.sling.serviceusermapper-1.3.0</connection>
+        <developerConnection>scm:svn:https://svn.apache.org/repos/asf/sling/tags/org.apache.sling.serviceusermapper-1.3.0</developerConnection>
+        <url>http://svn.apache.org/viewvc/sling/tags/org.apache.sling.serviceusermapper-1.3.0</url>
+    </scm>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <Import-Package>
+                            org.apache.felix.inventory;resolution:=optional,
+                            *
+                        </Import-Package>
+                        <DynamicImport-Package>
+                            org.apache.felix.inventory
+                        </DynamicImport-Package>
+                        <Embed-Dependency>
+                             org.apache.felix.utils;inline=org/apache/felix/utils/json/JSONWriter**
+                        </Embed-Dependency>
+                    </instructions>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <configuration>
+                    <excludePackageNames>
+                        org.apache.sling.serviceusermapping.impl
+                    </excludePackageNames>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.api</artifactId>
+            <version>2.3.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>org.apache.felix.utils</artifactId>
+            <version>1.9.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>org.apache.felix.inventory</artifactId>
+            <version>1.0.0</version>
+            <scope>provided</scope>
+        </dependency>
+  
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>osgi.core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.service.event</artifactId>
+            <version>1.3.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>1.9.5</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapped.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapped.java
new file mode 100644
index 0000000..921dffb
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapped.java
@@ -0,0 +1,43 @@
+/*
+ * 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.sling.serviceusermapping;
+
+import org.osgi.annotation.versioning.ProviderType;
+
+/**
+ * The <code>ServiceUserMapped</code> is a marker service that can be used to ensure that there is an already registered mapping for a certain service/subService.
+ * A service reference targeting a <code>ServiceUserMapped</code> will be satisfied only if <code>ServiceUserMapper.getServiceUserID</code>
+ * will resolve the subService to an userID.
+ * For example setting the reference target to "(subServiceName=mySubService)" ensures that your component only starts when the subService is available.
+ * The subServiceName will not be set for mappings that do not have one, and those can be referenced with a negating target "(!(subServiceName=*))".
+ * Trying to reference a sub service from a bundle for which it was not registered for will not work.
+ *
+ * As the service user mapper implementation is using a fallback, it is usually best to use a reference target that includes both
+ * options, the sub service name and the fallback, therefore a target like "(|((subServiceName=mySubService)(!(subServiceName=*))))" should be used.
+ */
+@ProviderType
+public interface ServiceUserMapped {
+
+
+    /**
+     * The name of the osgi property holding the sub service name.
+     */
+    static String SUBSERVICENAME = "subServiceName";
+
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapper.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapper.java
new file mode 100644
index 0000000..d8e6701
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserMapper.java
@@ -0,0 +1,74 @@
+/*
+ * 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.sling.serviceusermapping;
+
+import org.osgi.annotation.versioning.ProviderType;
+import org.osgi.framework.Bundle;
+
+/**
+ * The <code>ServiceUserMapper</code> service can be used to map a service
+ * provided by a bundle to the ID of a user account used to access the
+ * ResourceResolver used by the service to access its data.
+ * <p>
+ * The goal of this service is to allow services to be implemented accessing the
+ * storage with service-specific accounts which are tailored to allow the
+ * service appropriate access without requiring administrative level access to
+ * the storage.
+ * <p>
+ * In general a service is implement in a single bundle such as the JSP compiler
+ * bundle. Other services may be implemented in multiple bundles. In certain
+ * cases there may be sub-services requiring different access levels. For
+ * example a couple of bundles may implement a "mail" service where each bundle
+ * implements a part of the service such as the "smtp", "queuing", and
+ * "delivery" sub services. Such sub services are identified with the
+ * {@code subServiceName} parameter on the method calls.
+ * <p>
+ * In addition to allowing to phase out the use of
+ * {@code ResourceResolver.getAdministrativeResourceResolver} and
+ * {@code SlingRepository.loginAdministrative} it also allows to better account
+ * for changes to the storage by the different services.
+ * <p>
+ * This service is not intended to be used by the general user but by
+ * implementations of the {@code ResourceResolverFactory} and
+ * {@code SlingRepository} services.
+ * <p>
+ * This service is not intended to be implemented by clients.
+ *
+ * @see <a href=
+ *      "http://sling.apache.org/documentation/the-sling-engine/service-authentication.html"
+ *      >Service Authentication</a>
+ */
+@ProviderType
+public interface ServiceUserMapper {
+
+    /**
+     * Returns the ID of a user to access the data store on behalf of the
+     * service.
+     *
+     * @param bundle The bundle implementing the service request access to
+     *            resources.
+     * @param subServiceName Name of the sub service. This parameter is optional and
+     *            may be an empty string or {@code null}.
+     * @return The ID of the user to use to provide access to the resources for
+     *         the service. This may be {@code null} if no particular user can
+     *         be derived for the service identified by the bundle and the
+     *         optional {@code serviceInfo}.
+     */
+    String getServiceUserID(Bundle bundle, String subServiceName);
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserValidator.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserValidator.java
new file mode 100644
index 0000000..72faa34
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/ServiceUserValidator.java
@@ -0,0 +1,37 @@
+/*
+ * 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.sling.serviceusermapping;
+
+import org.osgi.annotation.versioning.ConsumerType;
+
+/**
+ * The {@code ServiceUserValidator} allows to implement validation of configured
+ * service user mappings.
+ */
+@ConsumerType
+public interface ServiceUserValidator {
+
+    /**
+     * Validates the configured service user ID.
+     *
+     * @param serviceUserId The ID of the configured service user.
+     * @param serviceName The name of the service
+     * @param subServiceName The optional sub service name.
+     * @return {@code true} if the configured service user is valid; {@code false} otherwise.
+     */
+    boolean isValid(String serviceUserId, String serviceName, String subServiceName);
+}
\ No newline at end of file
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/Mapping.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/Mapping.java
new file mode 100644
index 0000000..b4650c2
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/Mapping.java
@@ -0,0 +1,139 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+/**
+ * The <code>Mapping</code> class defines the mapping of a service's name and
+ * optional service information to a user name.
+ */
+class Mapping implements Comparable<Mapping> {
+
+
+    /**
+     * The name of the osgi property holding the service name.
+     */
+    static String SERVICENAME = ".serviceName";
+
+    private final String serviceName;
+
+    private final String subServiceName;
+
+    private final String userName;
+
+    /**
+     * Creates a mapping entry for the entry specification of the form:
+     *
+     * <pre>
+     * spec = serviceName [ ":" subServiceName ] "=" userName .
+     * </pre>
+     *
+     * @param spec The mapping specification.
+     * @throws NullPointerException if {@code spec} is {@code null}.
+     * @throws IllegalArgumentException if {@code spec} does not match the
+     *             expected pattern.
+     */
+    Mapping(final String spec) {
+
+        final int colon = spec.indexOf(':');
+        final int equals = spec.indexOf('=');
+
+        if (colon == 0 || equals <= 0) {
+            throw new IllegalArgumentException("serviceName is required");
+        } else if (equals == spec.length() - 1) {
+            throw new IllegalArgumentException("userName is required");
+        } else if (colon + 1 == equals) {
+            throw new IllegalArgumentException("serviceInfo must not be empty");
+        }
+
+        if (colon < 0 || colon > equals) {
+            this.serviceName = spec.substring(0, equals);
+            this.subServiceName = null;
+        } else {
+            this.serviceName = spec.substring(0, colon);
+            this.subServiceName = spec.substring(colon + 1, equals);
+        }
+
+        this.userName = spec.substring(equals + 1);
+    }
+
+    /**
+     * Returns the user name if the {@code serviceName} and the
+     * {@code serviceInfo} match. Otherwise {@code null} is returned.
+     *
+     * @param serviceName The name of the service to match. If this is
+     *            {@code null} this mapping will not match.
+     * @param subServiceName The Subservice Name to match. This may be
+     *            {@code null}.
+     * @return The user name if this mapping matches or {@code null} otherwise.
+     */
+    String map(final String serviceName, final String subServiceName) {
+        if (this.serviceName.equals(serviceName) && equals(this.subServiceName, subServiceName)) {
+            return userName;
+        }
+
+        return null;
+    }
+
+    private boolean equals(String str1, String str2) {
+        return ((str1 == null) ? str2 == null : str1.equals(str2));
+    }
+
+    @Override
+    public String toString() {
+        return "Mapping [serviceName=" + serviceName + ", subServiceName="
+                + subServiceName + ", userName=" + userName + "]";
+    }
+
+    public String getServiceName() {
+        return serviceName;
+    }
+
+    public String getSubServiceName() {
+        return subServiceName;
+    }
+
+
+    public int compareTo(Mapping o) {
+        if (o == null) {
+            return -1;
+        }
+
+        int result = compare(this.serviceName, o.serviceName);
+        if (result == 0) {
+            result = compare(this.subServiceName, o.subServiceName);
+        }
+        return result;
+    }
+
+    private int compare(String str1, String str2) {
+        if (str1 == str2) {
+            return 0;
+        }
+
+        if (str1 == null) {
+            return -1;
+        }
+
+        if (str2 == null) {
+            return 1;
+        }
+
+        return str1.hashCode() - str2.hashCode();
+    }
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingConfigAmendment.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingConfigAmendment.java
new file mode 100644
index 0000000..ff631cf
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingConfigAmendment.java
@@ -0,0 +1,107 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import java.util.ArrayList;
+
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ConfigurationPolicy;
+import org.osgi.service.component.annotations.Modified;
+import org.osgi.service.metatype.annotations.AttributeDefinition;
+import org.osgi.service.metatype.annotations.Designate;
+import org.osgi.service.metatype.annotations.ObjectClassDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Designate(factory=true, ocd=MappingConfigAmendment.Config.class)
+@Component(name = "org.apache.sling.serviceusermapping.impl.ServiceUserMapperImpl.amended",
+           configurationPolicy=ConfigurationPolicy.REQUIRE,
+           service={MappingConfigAmendment.class},
+           property= {
+                   "webconsole.configurationFactory.nameHint=Mapping: {user.mapping}",
+           })
+public class MappingConfigAmendment implements Comparable<MappingConfigAmendment> {
+
+    @ObjectClassDefinition(name ="Apache Sling Service User Mapper Service Amendment",
+            description="An amendment mapping for the user mapping service.")
+    public @interface Config {
+
+        @AttributeDefinition(name = "Ranking",
+              description="Amendments are processed in order of their ranking, an amendment with a higher ranking has" +
+                          " precedence over a mapping with a lower ranking.")
+        int service_ranking() default 0;
+
+        @AttributeDefinition(name = "Service Mappings",
+            description = "Provides mappings from service name to user names. "
+                + "Each entry is of the form 'bundleId [ \":\" subServiceName ] \"=\" userName' "
+                + "where bundleId and subServiceName identify the service and userName "
+                + "defines the name of the user to provide to the service. Invalid entries are logged and ignored.")
+        String[] user_mapping() default {};
+    }
+
+    /** default logger */
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private Mapping[] serviceUserMappings;
+
+    private int serviceRanking;
+
+    @Activate
+    @Modified
+    void configure(final Config config) {
+        final String[] props = config.user_mapping();
+
+        if ( props != null ) {
+            final ArrayList<Mapping> mappings = new ArrayList<Mapping>(props.length);
+            for (final String prop : props) {
+                if (prop != null && prop.trim().length() > 0 ) {
+                    try {
+                        final Mapping mapping = new Mapping(prop.trim());
+                        mappings.add(mapping);
+                    } catch (final IllegalArgumentException iae) {
+                        logger.info("configure: Ignoring '{}': {}", prop, iae.getMessage());
+                    }
+                }
+            }
+
+            this.serviceUserMappings = mappings.toArray(new Mapping[mappings.size()]);
+        } else {
+            this.serviceUserMappings = new Mapping[0];
+        }
+        this.serviceRanking = config.service_ranking();
+    }
+
+    public Mapping[] getServiceUserMappings() {
+        return this.serviceUserMappings;
+    }
+
+    @Override
+    public int compareTo(final MappingConfigAmendment o) {
+        // Sort by rank in descending order.
+        if ( this.serviceRanking > o.serviceRanking ) {
+            return -1; // lower rank
+        } else if (this.serviceRanking < o.serviceRanking) {
+            return 1; // higher rank
+        }
+
+        // If ranks are equal, then sort by hash code
+        return this.hashCode() < o.hashCode() ? -1 : 1;
+    }
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingInventoryPrinter.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingInventoryPrinter.java
new file mode 100644
index 0000000..e3488f5
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/MappingInventoryPrinter.java
@@ -0,0 +1,142 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import org.apache.felix.inventory.Format;
+import org.apache.felix.inventory.InventoryPrinter;
+import org.apache.felix.utils.json.JSONWriter;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+
+/** InventoryPrinter for service user mappings */
+@Component(service = InventoryPrinter.class,
+           property = {
+                   InventoryPrinter.FORMAT + "=JSON",
+                   InventoryPrinter.FORMAT + "=TEXT",
+                   InventoryPrinter.TITLE + "=Sling Service User Mappings",
+                   InventoryPrinter.WEBCONSOLE + ":Boolean=true"
+           })
+public class MappingInventoryPrinter implements InventoryPrinter {
+
+    @Reference
+    private ServiceUserMapperImpl mapper;
+
+    @Override
+    public void print(PrintWriter out, Format format, boolean isZip) {
+        try {
+            if(format.equals(Format.JSON)) {
+                renderJson(out);
+            } else if(format.equals(Format.TEXT)) {
+                renderText(out);
+            }
+        } catch(Exception e) {
+            e.printStackTrace(out);
+        }
+    }
+
+    private String getMappedUser(Mapping m) {
+        return m.map(m.getServiceName(), m.getSubServiceName());
+    }
+
+    private SortedMap<String, List<Mapping>> getMappingsByUser(List<Mapping> mappings) {
+        SortedMap<String, List<Mapping>> result = new TreeMap<String, List<Mapping>>();
+        for(Mapping m : mappings) {
+            final String user = getMappedUser(m);
+            List<Mapping> list = result.get(user);
+            if(list == null) {
+                list = new ArrayList<Mapping>();
+                result.put(user, list);
+            }
+            list.add(m);
+        }
+        return result;
+    }
+
+    private void asJSON(JSONWriter w, Mapping m) throws IOException {
+        w.object();
+        w.key("serviceName").value(m.getServiceName());
+        w.key("subServiceName").value(m.getSubServiceName());
+        w.key("user").value(getMappedUser(m));
+        w.endObject();
+    }
+
+    private void renderJson(PrintWriter out) throws IOException {
+        final List<Mapping> data = mapper.getActiveMappings();
+        final Map<String, List<Mapping>> byUser = getMappingsByUser(data);
+
+        final JSONWriter w = new JSONWriter(out);
+        w.object();
+        w.key("title").value("Service User Mappings");
+        w.key("mappingsCount").value(data.size());
+        w.key("uniqueUsersCount").value(byUser.keySet().size());
+
+        w.key("mappingsByUser");
+        w.object();
+        for(Map.Entry<String, List<Mapping>> e : byUser.entrySet()) {
+            w.key(e.getKey());
+            w.array();
+            for(Mapping m : e.getValue()) {
+                asJSON(w,m);
+            }
+            w.endArray();
+        }
+        w.endObject();
+
+        w.endObject();
+    }
+
+    private void asText(PrintWriter w, Mapping m, String indent) {
+        final String SEP = " / ";
+        w.print(indent);
+        w.print(m.getServiceName());
+        w.print(SEP);
+        final String sub = m.getSubServiceName();
+        w.print(sub == null ? "" : sub);
+        w.print(SEP);
+        w.println(getMappedUser(m));
+    }
+
+    private void renderText(PrintWriter out) {
+        final List<Mapping> data = mapper.getActiveMappings();
+        final Map<String, List<Mapping>> byUser = getMappingsByUser(data);
+
+        final String formatInfo = " (format: service name / sub service name / user)";
+
+        out.print("*** Mappings by user (");
+        out.print(byUser.keySet().size());
+        out.print(" users):");
+        out.println(formatInfo);
+
+        for(Map.Entry<String, List<Mapping>> e : byUser.entrySet()) {
+            out.print("  ");
+            out.println(e.getKey());
+            for(Mapping m : e.getValue()) {
+                asText(out, m, "    ");
+            }
+        }
+   }
+}
\ No newline at end of file
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilter.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilter.java
new file mode 100644
index 0000000..a8b0719
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilter.java
@@ -0,0 +1,93 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
+import org.osgi.framework.ServiceEvent;
+import org.osgi.framework.ServiceReference;
+import org.osgi.framework.hooks.service.EventListenerHook;
+import org.osgi.framework.hooks.service.FindHook;
+import org.osgi.framework.hooks.service.ListenerHook;
+import org.osgi.service.component.annotations.Component;
+
+/**
+ * The <code>ServiceUserMappingBundleFilter</code> only allows the bundle for which the service mapping is available to see it.
+ */
+@Component(immediate=true, // framework gets/ungets hooks each time
+           service = {EventListenerHook.class, FindHook.class} )
+public class ServiceUserMappedBundleFilter implements EventListenerHook, FindHook {
+
+    @Override
+    public void event(ServiceEvent serviceEvent, Map map) {
+
+        ServiceReference serviceReference = serviceEvent.getServiceReference();
+        if (isServiceMappingReference(serviceReference)) {
+            Object serviceName = serviceReference.getProperty(Mapping.SERVICENAME);
+
+            if (serviceName != null && serviceName instanceof String) {
+                Iterator<Map.Entry<BundleContext, Collection<ListenerHook.ListenerInfo>>> it = map.entrySet().iterator();
+                while (it.hasNext()) {
+                    BundleContext ctx = it.next().getKey();
+
+                    String bundleServiceName = ServiceUserMapperImpl.getServiceName(ctx.getBundle());
+                    if (!serviceName.equals(bundleServiceName)) {
+                        it.remove();
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void find(BundleContext bundleContext, String name, String filter, boolean allServices,
+                     Collection references) {
+        String bundleServiceName = ServiceUserMapperImpl.getServiceName(bundleContext.getBundle());
+
+        Iterator<ServiceReference> it = references.iterator();
+        while (it.hasNext()) {
+            ServiceReference serviceReference = it.next();
+            if (isServiceMappingReference(serviceReference)) {
+                Object serviceName = serviceReference.getProperty(Mapping.SERVICENAME);
+
+                if (serviceName != null && !serviceName.equals(bundleServiceName)) {
+                    it.remove();
+                }
+            }
+        }
+    }
+
+    private static boolean isServiceMappingReference(ServiceReference serviceReference) {
+        Object objectClass = serviceReference.getProperty(Constants.OBJECTCLASS);
+        for (Object o :  (Object[]) objectClass) {
+            if (ServiceUserMappedImpl.SERVICEUSERMAPPED.equals(o)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedImpl.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedImpl.java
new file mode 100644
index 0000000..3a7d2d7
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedImpl.java
@@ -0,0 +1,31 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import org.apache.sling.serviceusermapping.ServiceUserMapped;
+
+/**
+ * This is a trivial implementation of the marker interface <code>ServiceUserMapped</code>
+ */
+public class ServiceUserMappedImpl implements ServiceUserMapped {
+
+    static String SERVICEUSERMAPPED = ServiceUserMapped.class.getName();
+
+}
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImpl.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImpl.java
new file mode 100644
index 0000000..a7b8c48
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImpl.java
@@ -0,0 +1,441 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.apache.sling.serviceusermapping.ServiceUserMapped;
+import org.apache.sling.serviceusermapping.ServiceUserMapper;
+import org.apache.sling.serviceusermapping.ServiceUserValidator;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Modified;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.osgi.service.component.annotations.ReferencePolicy;
+import org.osgi.service.metatype.annotations.AttributeDefinition;
+import org.osgi.service.metatype.annotations.Designate;
+import org.osgi.service.metatype.annotations.ObjectClassDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Designate(ocd = ServiceUserMapperImpl.Config.class)
+@Component(service = {ServiceUserMapper.class, ServiceUserMapperImpl.class})
+public class ServiceUserMapperImpl implements ServiceUserMapper {
+
+    @ObjectClassDefinition(name = "Apache Sling Service User Mapper Service",
+        description = "Configuration for the service mapping service names to names of users.")
+    public @interface Config {
+
+        @AttributeDefinition(name = "Service Mappings",
+            description = "Provides mappings from service name to user names. "
+                + "Each entry is of the form 'bundleId [ \":\" subServiceName ] \"=\" userName' "
+                + "where bundleId and subServiceName identify the service and userName "
+                + "defines the name of the user to provide to the service. Invalid entries are logged and ignored.")
+        String[] user_mapping() default {};
+
+        @AttributeDefinition(name = "Default User",
+            description = "The name of the user to use as the default if no service mapping"
+                + " applies. If this property is missing or empty no default user is defined.")
+        String user_default();
+
+        @AttributeDefinition(name = "Default Mapping",
+                description = "If enabled and no mapping for a requested service user exists and no " +
+                      " default user is defined, a " +
+                     "default mapping is applied which uses the service user \"serviceuser@\" + {bundleId} + [\":\" + subServiceName]")
+        boolean user_enable_default_mapping() default true;
+    }
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private Mapping[] globalServiceUserMappings = new Mapping[0];
+
+    private String defaultUser;
+
+    private boolean useDefaultMapping;
+
+    private Map<Long, MappingConfigAmendment> amendments = new HashMap<>();
+
+    private Mapping[] activeMappings = new Mapping[0];
+
+    private final List<ServiceUserValidator> validators = new CopyOnWriteArrayList<>();
+
+    private SortedMap<Mapping, Registration> activeRegistrations = new TreeMap<>();
+
+    private BundleContext bundleContext;
+
+    private ExecutorService executorService;
+
+    public boolean registerAsync = true;
+
+    @Activate
+    @Modified
+    synchronized void configure(BundleContext bundleContext, final Config config) {
+        if (registerAsync && executorService == null) {
+            executorService = Executors.newSingleThreadExecutor();
+        }
+
+        final String[] props = config.user_mapping();
+
+        if ( props != null ) {
+            final ArrayList<Mapping> mappings = new ArrayList<>(props.length);
+            for (final String prop : props) {
+                if (prop != null && prop.trim().length() > 0 ) {
+                    try {
+                        final Mapping mapping = new Mapping(prop.trim());
+                        mappings.add(mapping);
+                    } catch (final IllegalArgumentException iae) {
+                        log.error("configure: Ignoring '{}': {}", prop, iae.getMessage());
+                    }
+                }
+            }
+
+            this.globalServiceUserMappings = mappings.toArray(new Mapping[mappings.size()]);
+        } else {
+            this.globalServiceUserMappings = new Mapping[0];
+        }
+        this.defaultUser = config.user_default();
+        this.useDefaultMapping = config.user_enable_default_mapping();
+
+        RegistrationSet registrationSet = null;
+        this.bundleContext = bundleContext;
+        registrationSet = this.updateMappings();
+
+        this.executeServiceRegistrationsAsync(registrationSet);
+    }
+
+    @Deactivate
+    synchronized void deactivate() {
+        // this call does not unregister the mappings, but they should be unbound
+        // through the unbind methods anyway
+        updateServiceRegistrations(new Mapping[0]);
+        bundleContext = null;
+        if (executorService != null) {
+            executorService.shutdown();
+            executorService = null;
+        }
+    }
+
+    private void restartAllActiveServiceUserMappedServices() {
+        RegistrationSet registrationSet = new RegistrationSet();
+        registrationSet.removed = activeRegistrations.values();
+        registrationSet.added = activeRegistrations.values();
+        executeServiceRegistrationsAsync(registrationSet);
+    }
+
+    /**
+     * bind the serviceUserValidator
+     * @param serviceUserValidator
+     */
+    @Reference(cardinality=ReferenceCardinality.MULTIPLE, policy= ReferencePolicy.DYNAMIC)
+    protected synchronized void bindServiceUserValidator(final ServiceUserValidator serviceUserValidator) {
+        validators.add(serviceUserValidator);
+        restartAllActiveServiceUserMappedServices();
+    }
+
+    /**
+     * unbind the serviceUserValidator
+     * @param serviceUserValidator
+     */
+    protected synchronized void unbindServiceUserValidator(final ServiceUserValidator serviceUserValidator) {
+        validators.remove(serviceUserValidator);
+        restartAllActiveServiceUserMappedServices();
+    }
+
+    /**
+     * @see org.apache.sling.serviceusermapping.ServiceUserMapper#getServiceUserID(org.osgi.framework.Bundle, java.lang.String)
+     */
+    @Override
+    public String getServiceUserID(final Bundle bundle, final String subServiceName) {
+        final String serviceName = getServiceName(bundle);
+        final String userId = internalGetUserId(serviceName, subServiceName);
+        final boolean valid = isValidUser(userId, serviceName, subServiceName);
+        final String result = valid ? userId : null;
+        log.debug(
+                "getServiceUserID(bundle {}, subServiceName {}) returns [{}] (raw userId={}, valid={})",
+                new Object[] { bundle, subServiceName, result, userId, valid });
+        return result;
+    }
+
+    @Reference(cardinality=ReferenceCardinality.MULTIPLE,policy=ReferencePolicy.DYNAMIC,updated="updateAmendment")
+    protected synchronized void bindAmendment(final MappingConfigAmendment amendment, final Map<String, Object> props) {
+        final Long key = (Long) props.get(Constants.SERVICE_ID);
+        RegistrationSet registrationSet = null;
+        amendments.put(key, amendment);
+        registrationSet = this.updateMappings();
+        executeServiceRegistrationsAsync(registrationSet);
+    }
+
+    protected synchronized void unbindAmendment(final MappingConfigAmendment amendment, final Map<String, Object> props) {
+        final Long key = (Long) props.get(Constants.SERVICE_ID);
+        RegistrationSet registrationSet = null;
+        if ( amendments.remove(key) != null ) {
+             registrationSet = this.updateMappings();
+        }
+        executeServiceRegistrationsAsync(registrationSet);
+    }
+
+    protected void updateAmendment(final MappingConfigAmendment amendment, final Map<String, Object> props) {
+        this.bindAmendment(amendment, props);
+    }
+
+    protected RegistrationSet updateMappings() {
+        final List<MappingConfigAmendment> sortedMappings = new ArrayList<>();
+        for(final MappingConfigAmendment amendment : this.amendments.values() ) {
+            sortedMappings.add(amendment);
+        }
+        Collections.sort(sortedMappings);
+
+        final List<Mapping> mappings = new ArrayList<>();
+        for(final Mapping m : this.globalServiceUserMappings) {
+            mappings.add(m);
+        }
+        for(final MappingConfigAmendment mca : sortedMappings) {
+            for(final Mapping m : mca.getServiceUserMappings()) {
+                mappings.add(m);
+            }
+        }
+
+        activeMappings = mappings.toArray(new Mapping[mappings.size()]);
+        log.debug("Active mappings updated: {} mappings active", mappings.size());
+
+        RegistrationSet registrationSet = updateServiceRegistrations(activeMappings);
+
+        return registrationSet;
+
+    }
+
+
+    RegistrationSet updateServiceRegistrations(final Mapping[] newMappings) {
+
+        RegistrationSet result = new RegistrationSet();
+        // do not do anything if not activated
+        if (bundleContext == null) {
+            return result;
+        }
+
+        final SortedSet<Mapping> orderedNewMappings = new TreeSet<>(Arrays.asList(newMappings));
+        final SortedMap<Mapping, Registration> newRegistrations = new TreeMap<>();
+
+        // keep those that are still mapped
+        for (Map.Entry<Mapping, Registration> registrationEntry: activeRegistrations.entrySet()) {
+            boolean keepEntry = true;
+
+            if (!orderedNewMappings.contains(registrationEntry.getKey())) {
+                Registration registration = registrationEntry.getValue();
+
+                result.removed.add(registration);
+                keepEntry = false;
+            }
+
+            if (keepEntry) {
+                newRegistrations.put(registrationEntry.getKey(), registrationEntry.getValue());
+            }
+        }
+
+        // add those that are new
+        for (final Mapping mapping: orderedNewMappings) {
+            if (!newRegistrations.containsKey(mapping)) {
+                Registration registration = new Registration(mapping);
+                newRegistrations.put(mapping, registration);
+                result.added.add(registration);
+            }
+        }
+
+        activeRegistrations = newRegistrations;
+
+        return result;
+    }
+
+    private void executeServiceRegistrationsAsync(final RegistrationSet registrationSet) {
+
+        if (executorService == null) {
+            executeServiceRegistrations(registrationSet);
+        } else {
+            executorService.submit(new Runnable() {
+                @Override
+                public void run() {
+                    executeServiceRegistrations(registrationSet);
+                }
+            });
+        }
+    }
+
+
+    private void executeServiceRegistrations(final RegistrationSet registrationSet) {
+
+        if (registrationSet == null) {
+            return;
+        }
+
+        for (final Registration registration : registrationSet.removed) {
+
+
+            ServiceRegistration serviceRegistration = registration.setService(null);
+
+            if (serviceRegistration != null) {
+                try {
+                    serviceRegistration.unregister();
+                    log.debug("Unregistered ServiceUserMapped {}", registration.mapping);
+                } catch (final IllegalStateException e) {
+                    // this can happen on shutdown, therefore we just ignore it and don't log
+                }
+            }
+        }
+
+        BundleContext savedBundleContext = bundleContext;
+
+        if (savedBundleContext == null) {
+            return;
+        }
+
+        for (final Registration registration : registrationSet.added) {
+            Mapping mapping = registration.mapping;
+            final Dictionary<String, Object> properties = new Hashtable<>();
+            if (mapping.getSubServiceName() != null) {
+                properties.put(ServiceUserMapped.SUBSERVICENAME, mapping.getSubServiceName());
+            }
+
+            properties.put(Mapping.SERVICENAME, mapping.getServiceName());
+            final ServiceRegistration serviceRegistration = savedBundleContext.registerService(ServiceUserMappedImpl.SERVICEUSERMAPPED,
+                    new ServiceUserMappedImpl(), properties);
+
+            ServiceRegistration oldServiceRegistration = registration.setService(serviceRegistration);
+            log.debug("Activated ServiceUserMapped {}", registration.mapping);
+
+            if (oldServiceRegistration != null) {
+                try {
+                    oldServiceRegistration.unregister();
+                } catch (final IllegalStateException e) {
+                    // this can happen on shutdown, therefore we just ignore it and don't log
+                }
+            }
+        }
+
+    }
+
+    private String internalGetUserId(final String serviceName, final String subServiceName) {
+        log.debug(
+                "internalGetUserId: {} active mappings, looking for mapping for {}/{}",
+                new Object[] { this.activeMappings.length, serviceName, subServiceName });
+
+        for (final Mapping mapping : this.activeMappings) {
+            final String userId = mapping.map(serviceName, subServiceName);
+            if (userId != null) {
+                log.debug("Got userId [{}] from {}/{}", new Object[] { userId, serviceName, subServiceName });
+                return userId;
+            }
+        }
+
+        // second round without serviceInfo
+        log.debug(
+                "internalGetUserId: {} active mappings, looking for mapping for {}/<no subServiceName>",
+                this.activeMappings.length, serviceName);
+
+        for (Mapping mapping : this.activeMappings) {
+            final String userId = mapping.map(serviceName, null);
+            if (userId != null) {
+                log.debug("Got userId [{}] from {}/<no subServiceName>", userId, serviceName);
+                return userId;
+            }
+        }
+
+        // use default mapping if configured and no default user
+        if ( this.defaultUser == null || this.defaultUser.isEmpty() ) {
+            final String userName = "serviceuser--" + serviceName + (subServiceName == null ? "" : "--" + subServiceName);
+            log.debug("internalGetUserId: no mapping found, using default mapping [{}]", userName);
+            return userName;
+
+        }
+        log.debug("internalGetUserId: no mapping found, fallback to default user [{}]", this.defaultUser);
+        return this.defaultUser;
+    }
+
+    private boolean isValidUser(final String userId, final String serviceName, final String subServiceName) {
+        if (userId == null) {
+            log.debug("isValidUser: userId is null -> invalid");
+            return false;
+        }
+        if ( !validators.isEmpty() ) {
+            for (final ServiceUserValidator validator : validators) {
+                if ( validator.isValid(userId, serviceName, subServiceName) ) {
+                    log.debug("isValidUser: Validator {} accepts userId [{}] -> valid", validator, userId);
+                    return true;
+                }
+            }
+            log.debug("isValidUser: No validator accepted userId [{}] -> invalid", userId);
+            return false;
+        } else {
+            log.debug("isValidUser: No active validators for userId [{}] -> valid", userId);
+            return true;
+        }
+    }
+
+    static String getServiceName(final Bundle bundle) {
+        return bundle.getSymbolicName();
+    }
+
+    List<Mapping> getActiveMappings() {
+        return Collections.unmodifiableList(Arrays.asList(activeMappings));
+    }
+
+    class Registration {
+        private Mapping mapping;
+        private ServiceRegistration serviceRegistration;
+
+
+        Registration(Mapping mapping) {
+            this.mapping = mapping;
+            this.serviceRegistration = null;
+        }
+
+        synchronized ServiceRegistration setService(ServiceRegistration serviceRegistration) {
+            ServiceRegistration oldServiceRegistration = this.serviceRegistration;
+            this.serviceRegistration = serviceRegistration;
+            return oldServiceRegistration;
+        }
+    }
+
+    class RegistrationSet {
+        Collection<Registration> added = new ArrayList<>();
+        Collection<Registration> removed = new ArrayList<>();
+    }
+}
+
diff --git a/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/package-info.java b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/package-info.java
new file mode 100644
index 0000000..69a2cdd
--- /dev/null
+++ b/serviceusermapper/src/main/java/org/apache/sling/serviceusermapping/package-info.java
@@ -0,0 +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.
+ */
+
+@org.osgi.annotation.versioning.Version("1.2.1")
+package org.apache.sling.serviceusermapping;
+
diff --git a/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/MappingTest.java b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/MappingTest.java
new file mode 100644
index 0000000..7764d79
--- /dev/null
+++ b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/MappingTest.java
@@ -0,0 +1,141 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import java.lang.reflect.Field;
+
+import junit.framework.TestCase;
+
+import org.apache.sling.serviceusermapping.impl.Mapping;
+import org.junit.Test;
+
+public class MappingTest {
+
+    @Test
+    public void test_constructor_null() {
+        try {
+            new Mapping(null);
+            TestCase.fail("NullPointerException expected");
+        } catch (NullPointerException npe) {
+            // expected
+        }
+    }
+
+    @Test
+    public void test_constructor_empty() {
+        try {
+            new Mapping("");
+            TestCase.fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException iae) {
+            // expected
+        }
+    }
+
+    @Test
+    public void test_constructor_missing_user_name() {
+        try {
+            new Mapping("serviceName");
+            TestCase.fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException iae) {
+            // expected
+        }
+
+        try {
+            new Mapping("serviceName=");
+            TestCase.fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException iae) {
+            // expected
+        }
+    }
+
+    @Test
+    public void test_constructor_missing_service_name() {
+        try {
+            new Mapping("=user");
+            TestCase.fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException iae) {
+            // expected
+        }
+    }
+
+    @Test
+    public void test_constructor_empty_service_info() {
+        try {
+            new Mapping("srv:=user");
+            TestCase.fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException iae) {
+            // expected
+        }
+    }
+
+    @Test
+    public void test_constructor_user_with_colon() {
+        new Mapping("srv=jcr:user");
+    }
+
+    @Test
+    public void test_constructor_and_map() {
+        assertMapping("service", null, "user");
+        assertMapping("service", "subServiceName", "user");
+    }
+
+    private void assertMapping(final String serviceName, final String subServiceName, final String userName) {
+        StringBuilder spec = new StringBuilder();
+        spec.append(serviceName);
+        if (subServiceName != null) {
+            spec.append(':').append(subServiceName);
+        }
+        spec.append('=').append(userName);
+
+        // spec analysis
+        final Mapping mapping = new Mapping(spec.toString());
+        TestCase.assertEquals(getField(mapping, "serviceName"), serviceName);
+        TestCase.assertEquals(getField(mapping, "subServiceName"), subServiceName);
+        TestCase.assertEquals(getField(mapping, "userName"), userName);
+
+        // mapping
+        TestCase.assertEquals(userName, mapping.map(serviceName, subServiceName));
+        if (subServiceName == null) {
+            // Mapping without subServiceName must not match request with any
+            // subServiceName
+            TestCase.assertNull(mapping.map(serviceName, subServiceName + "-garbage"));
+        } else {
+            // Mapping with subServiceName must not match request without
+            // subServiceName
+            TestCase.assertNull(mapping.map(serviceName, null));
+        }
+
+        // no match for different service name
+        TestCase.assertNull(mapping.map(serviceName + "-garbage", subServiceName));
+
+        // no match for null service name
+        TestCase.assertNull(mapping.map(null, subServiceName));
+    }
+
+    private String getField(final Object object, final String fieldName) {
+        try {
+            Field f = object.getClass().getDeclaredField(fieldName);
+            f.setAccessible(true);
+            return (String) f.get(object);
+        } catch (Exception e) {
+            TestCase.fail("Cannot get field " + fieldName + ": " + e.toString());
+            return null; // will not get here, quiesce compiler
+        }
+    }
+}
diff --git a/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilterTest.java b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilterTest.java
new file mode 100644
index 0000000..9f12426
--- /dev/null
+++ b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMappedBundleFilterTest.java
@@ -0,0 +1,115 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+
+import junit.framework.TestCase;
+import org.junit.Test;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Constants;
+import org.osgi.framework.ServiceEvent;
+import org.osgi.framework.ServiceReference;
+import org.osgi.framework.hooks.service.EventListenerHook;
+import org.osgi.framework.hooks.service.FindHook;
+import org.osgi.framework.hooks.service.ListenerHook;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test reference and bundle filtering based on <code>Mapping.SERVICENAME</code>
+ */
+public class ServiceUserMappedBundleFilterTest {
+
+    final static String BUNDLE1 = "bundle1";
+    final static String BUNDLE2 = "bundle2";
+
+
+    final static BundleContext bundleContext1;
+    final static BundleContext bundleContext2;
+
+    static  {
+        bundleContext1 = mock(BundleContext.class);
+        Bundle bundle1 = mock(Bundle.class);
+        when(bundleContext1.getBundle()).thenReturn(bundle1);
+        when(bundle1.getSymbolicName()).thenReturn(BUNDLE1);
+
+
+        bundleContext2 = mock(BundleContext.class);
+        Bundle bundle2 = mock(Bundle.class);
+        when(bundleContext2.getBundle()).thenReturn(bundle2);
+        when(bundle2.getSymbolicName()).thenReturn(BUNDLE2);
+
+    }
+
+
+
+
+    @Test
+    public void testEvent() {
+        Map<BundleContext, Collection<ListenerHook.ListenerInfo>> map = new HashMap<BundleContext, Collection<ListenerHook.ListenerInfo>>();
+
+        map.put(bundleContext1, new ArrayList<ListenerHook.ListenerInfo>());
+        map.put(bundleContext2, new ArrayList<ListenerHook.ListenerInfo>());
+
+        ServiceEvent serviceEvent = mock(ServiceEvent.class);
+        ServiceReference serviceReference = mock(ServiceReference.class);
+        when(serviceEvent.getServiceReference()).thenReturn(serviceReference);
+        when(serviceReference.getProperty(Constants.OBJECTCLASS)).thenReturn(new String[]{ServiceUserMappedImpl.SERVICEUSERMAPPED});
+        when(serviceReference.getProperty(Mapping.SERVICENAME)).thenReturn(BUNDLE1);
+
+
+        EventListenerHook eventListenerHook = new ServiceUserMappedBundleFilter();
+        eventListenerHook.event(serviceEvent, map);
+
+        TestCase.assertEquals(1, map.size());
+        TestCase.assertTrue(map.containsKey(bundleContext1));
+
+    }
+
+    @Test
+    public void testFind() {
+        List collection = new ArrayList<ServiceReference>();
+
+        ServiceReference serviceReference1 = mock(ServiceReference.class);
+        ServiceReference serviceReference2 = mock(ServiceReference.class);
+        collection.add(serviceReference1);
+        collection.add(serviceReference2);
+
+        when(serviceReference1.getProperty(Mapping.SERVICENAME)).thenReturn(BUNDLE1);
+        when(serviceReference1.getProperty(Constants.OBJECTCLASS)).thenReturn(new String[]{ServiceUserMappedImpl.SERVICEUSERMAPPED});
+
+        when(serviceReference2.getProperty(Mapping.SERVICENAME)).thenReturn(BUNDLE2);
+        when(serviceReference2.getProperty(Constants.OBJECTCLASS)).thenReturn(new String[]{ServiceUserMappedImpl.SERVICEUSERMAPPED});
+
+        FindHook findHook = new ServiceUserMappedBundleFilter();
+        findHook.find(bundleContext1, null, null, false, collection);
+
+        TestCase.assertEquals(1, collection.size());
+        TestCase.assertTrue(collection.contains(serviceReference1));
+    }
+}
diff --git a/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImplTest.java b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImplTest.java
new file mode 100644
index 0000000..8d0b719
--- /dev/null
+++ b/serviceusermapper/src/test/java/org/apache/sling/serviceusermapping/impl/ServiceUserMapperImplTest.java
@@ -0,0 +1,380 @@
+/*
+ * 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.sling.serviceusermapping.impl;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Dictionary;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.sling.serviceusermapping.ServiceUserValidator;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.osgi.framework.ServiceRegistration;
+
+import junit.framework.TestCase;
+
+public class ServiceUserMapperImplTest {
+    private static final String BUNDLE_SYMBOLIC1 = "bundle1";
+
+    private static final String BUNDLE_SYMBOLIC2 = "bundle2";
+
+    private static final String BUNDLE_SYMBOLIC3 = "bundle3";
+
+    private static final String SUB = "sub";
+
+    private static final String NONE = "none";
+
+    private static final String SAMPLE = "sample";
+
+    private static final String ANOTHER = "another";
+
+    private static final String SAMPLE_SUB = "sample_sub";
+
+    private static final String ANOTHER_SUB = "another_sub";
+
+    private static final Bundle BUNDLE1;
+
+    private static final Bundle BUNDLE2;
+
+    private static final Bundle BUNDLE3;
+
+    static {
+        BUNDLE1 = mock(Bundle.class);
+        when(BUNDLE1.getSymbolicName()).thenReturn(BUNDLE_SYMBOLIC1);
+
+        BUNDLE2 = mock(Bundle.class);
+        when(BUNDLE2.getSymbolicName()).thenReturn(BUNDLE_SYMBOLIC2);
+
+        BUNDLE3 = mock(Bundle.class);
+        when(BUNDLE3.getSymbolicName()).thenReturn(BUNDLE_SYMBOLIC3);
+    }
+
+    @Test
+    public void test_getServiceUserID() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+            BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+            BUNDLE_SYMBOLIC2 + "=" + ANOTHER, //
+            BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+            BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB //
+        });
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(false);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, null));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, null));
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, ""));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, ""));
+        TestCase.assertEquals(SAMPLE_SUB, sum.getServiceUserID(BUNDLE1, SUB));
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, SUB));
+        TestCase.assertEquals(NONE, sum.getServiceUserID(BUNDLE3, null));
+        TestCase.assertEquals(NONE, sum.getServiceUserID(BUNDLE3, SUB));
+    }
+
+    @Test
+    public void test_getServiceUserIDwithDefaultMappingEnabledAndDefaultUser() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+            BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+            BUNDLE_SYMBOLIC2 + "=" + ANOTHER, //
+            BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+            BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB //
+        });
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(true);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, null));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, null));
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, ""));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, ""));
+        TestCase.assertEquals(SAMPLE_SUB, sum.getServiceUserID(BUNDLE1, SUB));
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, SUB));
+        TestCase.assertEquals(NONE, sum.getServiceUserID(BUNDLE3, null));
+        TestCase.assertEquals(NONE, sum.getServiceUserID(BUNDLE3, SUB));
+    }
+
+    @Test
+    public void test_getServiceUserIDwithDefaultMappingEnabledAndNoDefaultUser() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+            BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+            BUNDLE_SYMBOLIC2 + "=" + ANOTHER, //
+            BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+            BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB //
+        });
+        when(config.user_default()).thenReturn(null);
+        when(config.user_enable_default_mapping()).thenReturn(true);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, null));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, null));
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, ""));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, ""));
+        TestCase.assertEquals(SAMPLE_SUB, sum.getServiceUserID(BUNDLE1, SUB));
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, SUB));
+        TestCase.assertEquals("serviceuser--" + BUNDLE_SYMBOLIC3, sum.getServiceUserID(BUNDLE3, null));
+        TestCase.assertEquals("serviceuser--" + BUNDLE_SYMBOLIC3 + "--" + SUB, sum.getServiceUserID(BUNDLE3, SUB));
+    }
+
+    @Test
+    public void test_getServiceUserID_WithServiceUserValidator() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+                BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+                BUNDLE_SYMBOLIC2 + "=" + ANOTHER, //
+                BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+                BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB //
+        });
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(false);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+        ServiceUserValidator serviceUserValidator = new ServiceUserValidator() {
+
+            @Override
+            public boolean isValid(String serviceUserId, String serviceName,
+                    String subServiceName) {
+                if (SAMPLE.equals(serviceUserId)) {
+                    return false;
+                }
+                return true;
+            }
+        };
+        sum.bindServiceUserValidator(serviceUserValidator);
+
+        TestCase.assertEquals(null, sum.getServiceUserID(BUNDLE1, null));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, null));
+        TestCase.assertEquals(null, sum.getServiceUserID(BUNDLE1, ""));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, ""));
+        TestCase.assertEquals(SAMPLE_SUB, sum.getServiceUserID(BUNDLE1, SUB));
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, SUB));
+    }
+
+    @Test
+    public void test_amendment() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+                BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+                BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+        });
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(false);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+        final MappingConfigAmendment mca1 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca1Config = mock(MappingConfigAmendment.Config.class);
+        when(mca1Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + "=" + ANOTHER});
+        when(mca1Config.service_ranking()).thenReturn(100);
+        Map<String, Object> mca1ConfigMap = new HashMap<>();
+        mca1ConfigMap.put("user.mapping", mca1Config.user_mapping());
+        mca1ConfigMap.put("service.ranking", mca1Config.service_ranking());
+        mca1ConfigMap.put("service.id", 1L);
+
+        mca1.configure(mca1Config);
+        sum.bindAmendment(mca1, mca1ConfigMap);
+        final MappingConfigAmendment mca2 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca2Config = mock(MappingConfigAmendment.Config.class);
+        when(mca2Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB});
+        when(mca2Config.service_ranking()).thenReturn(200);
+        Map<String, Object> mca2ConfigMap = new HashMap<>();
+        mca2ConfigMap.put("user.mapping", mca2Config.user_mapping());
+        mca2ConfigMap.put("service.ranking", mca2Config.service_ranking());
+        mca2ConfigMap.put("service.id", 2L);
+
+        mca2.configure(mca2Config);
+        sum.bindAmendment(mca2, mca2ConfigMap);
+
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, null));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, null));
+        TestCase.assertEquals(SAMPLE, sum.getServiceUserID(BUNDLE1, ""));
+        TestCase.assertEquals(ANOTHER, sum.getServiceUserID(BUNDLE2, ""));
+        TestCase.assertEquals(SAMPLE_SUB, sum.getServiceUserID(BUNDLE1, SUB));
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, SUB));
+    }
+
+    @Test
+    public void test_amendmentOverlap() {
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {});
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(false);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.configure(null, config);
+
+        final MappingConfigAmendment mca1 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca1Config = mock(MappingConfigAmendment.Config.class);
+        when(mca1Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + "=" + ANOTHER});
+        when(mca1Config.service_ranking()).thenReturn(100);
+        Map<String, Object> mca1ConfigMap = new HashMap<>();
+        mca1ConfigMap.put("user.mapping", mca1Config.user_mapping());
+        mca1ConfigMap.put("service.ranking", mca1Config.service_ranking());
+
+        mca1.configure(mca1Config);
+        final MappingConfigAmendment mca2 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca2Config = mock(MappingConfigAmendment.Config.class);
+        when(mca2Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + "=" + ANOTHER_SUB});
+        when(mca2Config.service_ranking()).thenReturn(200);
+        Map<String, Object> mca2ConfigMap = new HashMap<>();
+        mca2ConfigMap.put("user.mapping", mca2Config.user_mapping());
+        mca2ConfigMap.put("service.ranking", mca2Config.service_ranking());
+
+        mca2.configure(mca2Config);
+
+        sum.bindAmendment(mca1, mca1ConfigMap);
+        sum.bindAmendment(mca2, mca2ConfigMap);
+
+        TestCase.assertEquals(ANOTHER_SUB, sum.getServiceUserID(BUNDLE2, ""));
+    }
+
+
+
+    @Test
+    public void test_amendmentServiceUserMapping() {
+
+        ServiceUserMapperImpl.Config config = mock(ServiceUserMapperImpl.Config.class);
+        when(config.user_mapping()).thenReturn(new String[] {
+                BUNDLE_SYMBOLIC1 + "=" + SAMPLE, //
+                BUNDLE_SYMBOLIC1 + ":" + SUB + "=" + SAMPLE_SUB, //
+                });
+        when(config.user_default()).thenReturn(NONE);
+        when(config.user_enable_default_mapping()).thenReturn(false);
+
+        final ServiceUserMapperImpl sum = new ServiceUserMapperImpl();
+        sum.registerAsync = false;
+        final ServiceRegistrationContextHelper context = new ServiceRegistrationContextHelper();
+        sum.configure(context.getBundleContext(), config);
+
+        TestCase.assertEquals(2, context.getRegistrations(ServiceUserMappedImpl.SERVICEUSERMAPPED).size());
+
+        final MappingConfigAmendment mca1 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca1Config = mock(MappingConfigAmendment.Config.class);
+        when(mca1Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + "=" + ANOTHER});
+        when(mca1Config.service_ranking()).thenReturn(100);
+        Map<String, Object> mca1ConfigMap = new HashMap<>();
+        mca1ConfigMap.put("user.mapping", mca1Config.user_mapping());
+        mca1ConfigMap.put("service.ranking", mca1Config.service_ranking());
+        mca1ConfigMap.put("service.id", 1L);
+
+        mca1.configure(mca1Config);
+        sum.bindAmendment(mca1, mca1ConfigMap);
+
+        TestCase.assertEquals(3, context.getRegistrations(ServiceUserMappedImpl.SERVICEUSERMAPPED).size());
+
+        final MappingConfigAmendment mca2 = new MappingConfigAmendment();
+
+        MappingConfigAmendment.Config mca2Config = mock(MappingConfigAmendment.Config.class);
+        when(mca2Config.user_mapping()).thenReturn(new String[] {BUNDLE_SYMBOLIC2 + ":" + SUB + "=" + ANOTHER_SUB});
+        when(mca2Config.service_ranking()).thenReturn(200);
+        Map<String, Object> mca2ConfigMap = new HashMap<>();
+        mca2ConfigMap.put("user.mapping", mca2Config.user_mapping());
+        mca2ConfigMap.put("service.ranking", mca2Config.service_ranking());
+        mca2ConfigMap.put("service.id", 2L);
+
+        mca2.configure(mca2Config);
+        sum.bindAmendment(mca2, mca2ConfigMap);
+
+        TestCase.assertEquals(4, context.getRegistrations(ServiceUserMappedImpl.SERVICEUSERMAPPED).size());
+
+        sum.unbindAmendment(mca1, mca1ConfigMap);
+
+        TestCase.assertEquals(3, context.getRegistrations(ServiceUserMappedImpl.SERVICEUSERMAPPED).size());
+    }
+
+
+    private class ServiceRegistrationContextHelper {
+
+
+        final BundleContext bundleContext = mock(BundleContext.class);
+        final Map<String, Map<Object, Dictionary>> registrations = new HashMap<>();
+
+        public ServiceRegistrationContextHelper() {
+            when(bundleContext.registerService(any(String.class), any(Object.class), any(Dictionary.class)))
+                    .then(new Answer<ServiceRegistration>() {
+                        @Override
+                        public ServiceRegistration answer(InvocationOnMock invocationOnMock) throws Throwable {
+
+                            Object[] arguments = invocationOnMock.getArguments();
+                            return registerService((String) arguments[0], arguments[1], (Dictionary) arguments[2]);
+                        }
+                    });
+        }
+
+        private ServiceRegistration registerService(String string, Object o, Dictionary dictionary) {
+            if (!registrations.containsKey(string)) {
+                registrations.put(string, new HashMap<Object, Dictionary>());
+            }
+            final Map<Object, Dictionary> serviceRegistrations = registrations.get(string);
+            serviceRegistrations.put(o, dictionary);
+
+            final Object registeredObject = o;
+
+
+            return new ServiceRegistration() {
+                @Override
+                public ServiceReference getReference() {
+                    return null;
+                }
+
+                @Override
+                public void setProperties(Dictionary dictionary) {
+
+                }
+
+                @Override
+                public void unregister() {
+                    serviceRegistrations.remove(registeredObject);
+                }
+            };
+        }
+
+        public Map<Object, Dictionary> getRegistrations(String name) {
+            return registrations.get(name);
+        }
+
+        public BundleContext getBundleContext() {
+            return bundleContext;
+        }
+
+    }
+
+}