diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/EtcMappingResourceResolverTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/EtcMappingResourceResolverTest.java
new file mode 100644
index 0000000..b8f73e1
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/EtcMappingResourceResolverTest.java
@@ -0,0 +1,309 @@
+/*
+ * 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.resourceresolver.impl;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ResourceResolverFactory;
+import org.apache.sling.api.resource.observation.ResourceChange;
+import org.apache.sling.api.resource.path.Path;
+import org.apache.sling.resourceresolver.impl.mapping.MapConfigurationProvider;
+import org.apache.sling.resourceresolver.impl.mapping.MapEntries;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderHandler;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderStorage;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderTracker;
+import org.apache.sling.serviceusermapping.ServiceUserMapper;
+import org.apache.sling.spi.resource.provider.ResourceProvider;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.service.event.EventAdmin;
+
+import javax.servlet.http.HttpServletRequest;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Arrays.asList;
+import static org.apache.sling.resourceresolver.impl.MockedResourceResolverImplTest.createRPHandler;
+import static org.apache.sling.resourceresolver.impl.ResourceResolverImpl.PROP_REDIRECT_INTERNAL;
+import static org.apache.sling.resourceresolver.impl.mapping.MapEntries.PROP_REDIRECT_EXTERNAL;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.ExpectedEtcMapping;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.buildResource;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.callInaccessibleMethod;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.checkInternalResource;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.checkRedirectResource;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.createRequestFromUrl;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.setInaccessibleField;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+/**
+ * These are the same tests as in the EtcMappingMapEntriesTest but in this
+ * class we are actually mocking the Resource Resolver Factory and its classes
+ * and we test the mapping and resource resolution through the resource resolver
+ * rather the MapEntries.
+ */
+public class EtcMappingResourceResolverTest {
+
+    static final String PROP_REG_EXP = "sling:match";
+
+    @Mock
+    ResourceResolverFactory resourceResolverFactory;
+
+    @Mock
+    BundleContext bundleContext;
+
+    @Mock
+    Bundle bundle;
+
+    @Mock
+    EventAdmin eventAdmin;
+
+    @Mock
+    ResourceResolver resourceResolver;
+
+    @Mock
+    ResourceProvider<?> resourceProvider;
+
+    MapEntries mapEntries;
+
+    File vanityBloomFilterFile;
+
+    CommonResourceResolverFactoryImpl commonFactory;
+
+    Resource etc;
+    Resource map;
+    Resource http;
+
+    Map<String, Map<String, String>> aliasMap;
+
+    @SuppressWarnings({"unchecked"})
+    @Before
+    public void setup() throws Exception {
+        MockitoAnnotations.initMocks(this);
+
+        List<MapConfigurationProvider.VanityPathConfig> configs = getVanityPathConfigs();
+        vanityBloomFilterFile = new File("target/test-classes/resourcesvanityBloomFilter.txt");
+        List<ResourceProviderHandler> handlers = asList(createRPHandler(resourceProvider, "rp1", 0, "/"));
+        ResourceProviderTracker resourceProviderTracker = mock(ResourceProviderTracker.class);
+        ResourceProviderStorage storage = new ResourceProviderStorage(handlers);
+        when(resourceProviderTracker.getResourceProviderStorage()).thenReturn(storage);
+        ResourceResolverFactoryActivator activator = new ResourceResolverFactoryActivator();
+        // These fields on the Activator a package private so we need reflection to access them
+        setInaccessibleField("resourceProviderTracker", activator, resourceProviderTracker);
+        setInaccessibleField("resourceAccessSecurityTracker", activator, new ResourceAccessSecurityTracker());
+        setInaccessibleField("bundleContext", activator, bundleContext);
+        setInaccessibleField("mapRoot", activator, "/etc/map");
+        setInaccessibleField("mapRootPrefix", activator, "/etc/map");
+        setInaccessibleField("observationPaths", activator, new Path[] {new Path("/")});
+        ServiceUserMapper serviceUserMapper = mock(ServiceUserMapper.class);
+        setInaccessibleField("serviceUserMapper", activator, serviceUserMapper);
+        commonFactory = spy(new CommonResourceResolverFactoryImpl(activator));
+        when(bundleContext.getBundle()).thenReturn(bundle);
+        when(bundleContext.getDataFile("vanityBloomFilter.txt")).thenReturn(vanityBloomFilterFile);
+        when(serviceUserMapper.getServiceUserID(any(Bundle.class),anyString())).thenReturn("mapping");
+        // Activate method is package private so we use reflection to to call it
+        callInaccessibleMethod("activate", null, commonFactory, BundleContext.class, bundleContext);
+        final Bundle usingBundle = mock(Bundle.class);
+        resourceResolverFactory = new ResourceResolverFactoryImpl(commonFactory, usingBundle, null);
+        resourceResolver = resourceResolverFactory.getAdministrativeResourceResolver(null);
+
+        etc = buildResource("/etc", null, resourceResolver, resourceProvider);
+        map = buildResource("/etc/map", etc, resourceResolver, resourceProvider);
+        http = buildResource("/etc/map/http", map, resourceResolver, resourceProvider);
+    }
+
+    List<MapConfigurationProvider.VanityPathConfig> getVanityPathConfigs() {
+        return new ArrayList<>();
+    }
+
+    /**
+     * Changes to the /etc/map in our tests are not taking effect until there is an Change Event issued
+     *
+     * ATTENTION: this method can only be issued once. After that the Resource Metadata is locked and
+     * hence updates will fail
+     *
+     * @param path Path to the resource root to be refreshed
+     * @param isExternal External flag of the ResourceChange event
+     */
+    void refreshMapEntries(String path, boolean isExternal) {
+        ((MapEntries) commonFactory.getMapEntries()).onChange(
+            asList(
+                new ResourceChange(ResourceChange.ChangeType.ADDED, path, isExternal)
+            )
+        );
+    }
+
+    @Test
+    public void root_node_to_content_mapping() throws Exception {
+        buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content/simple-node");
+        // This updates the map entries so that the newly added resources are added.
+        // ATTENTION: only call this after all etc-mapping resources are defined as this lock their Resource Meta Data and prevents a re-update
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-node/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());
+
+        HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkRedirectResource(resolvedResource, "/content/simple-node/", 302);
+    }
+
+    @Test
+    public void match_to_content_mapping() throws Exception {
+        buildResource("test-node", http, resourceResolver, resourceProvider,
+            PROP_REG_EXP, "localhost.8080/",
+            PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
+        );
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-match/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for match to content", commonFactory.getMapEntries().getResolveMaps());
+
+        HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkRedirectResource(resolvedResource, "/content/simple-match/", 302);
+    }
+
+    // The following tests are based on the example from the https://sling.apache.org/documentation/the-sling-engine/mappings-for-resource-resolution.html page
+
+    @Test
+    public void internal_to_external_node_mapping() throws Exception {
+        buildResource("example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "http://www.example.com/");
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/example.com.80/", "http://www.example.com/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for internal to external based on node", commonFactory.getMapEntries().getResolveMaps());
+
+        HttpServletRequest request = createRequestFromUrl("http://example.com/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkRedirectResource(resolvedResource, "http://www.example.com/", 302);
+    }
+
+    @Test
+    public void internal_root_to_content_node_mapping() throws Exception {
+        buildResource("/example", null, resourceResolver, resourceProvider);
+
+        buildResource("www.example.com.80", http, resourceResolver, resourceProvider, PROP_REDIRECT_INTERNAL, "/example");
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/www.example.com.80/", true, "/example/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for internal root to content", commonFactory.getMapEntries().getResolveMaps());
+
+        HttpServletRequest request = createRequestFromUrl("http://www.example.com:80/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkInternalResource(resolvedResource, "/example");
+    }
+
+    @Test
+    public void host_redirect_match_mapping() throws Exception {
+        buildResource("any_example.com.80", http, resourceResolver, resourceProvider,
+            PROP_REG_EXP, ".+\\.example\\.com\\.80",
+            PROP_REDIRECT_EXTERNAL, "http://www.example.com/"
+        );
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/.+\\.example\\.com\\.80", false, "http://www.example.com/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for host redirect match mapping", commonFactory.getMapEntries().getResolveMaps());
+
+        HttpServletRequest request = createRequestFromUrl("http://www.example.com");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkRedirectResource(resolvedResource, "http://www.example.com//", 302);
+    }
+
+    @Test
+    public void nested_internal_mixed_mapping() throws Exception {
+        Resource localhost = buildResource("localhost_any", http, resourceResolver, resourceProvider,
+            PROP_REG_EXP, "localhost\\.\\d*",
+            PROP_REDIRECT_INTERNAL, "/content"
+        );
+        buildResource("cgi-bin", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/scripts");
+        buildResource("gateway", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "http://gbiv.com");
+        buildResource("(stories)", localhost, resourceResolver, resourceProvider,PROP_REDIRECT_INTERNAL, "/anecdotes/$1");
+
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping()
+            .addEtcMapEntry("^http/localhost\\.\\d*", true, "/content")
+            .addEtcMapEntry("^http/localhost\\.\\d*/cgi-bin/", true, "/scripts/")
+            .addEtcMapEntry("^http/localhost\\.\\d*/gateway/", true, "http://gbiv.com/")
+            .addEtcMapEntry("^http/localhost\\.\\d*/(stories)/", true, "/anecdotes/$1/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for nested internal mixed mapping", commonFactory.getMapEntries().getResolveMaps());
+
+        buildResource("/content", null, resourceResolver, resourceProvider);
+        Resource scripts = buildResource("/scripts", null, resourceResolver, resourceProvider);
+        Resource scriptsChild = buildResource("/scripts/child", scripts, resourceResolver, resourceProvider);
+        Resource anecdotes = buildResource("/anecdotes", null, resourceResolver, resourceProvider);
+        Resource stories = buildResource("/anecdotes/stories", anecdotes, resourceResolver, resourceProvider);
+
+        HttpServletRequest request = createRequestFromUrl("http://localhost:1234/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/");
+        checkInternalResource(resolvedResource, "/content");
+
+        resolvedResource = resourceResolver.resolve(request, "/cgi-bin/");
+        checkInternalResource(resolvedResource, "/scripts");
+        resolvedResource = resourceResolver.resolve(request, "/cgi-bin/child/");
+        checkInternalResource(resolvedResource, "/scripts/child");
+//AS TODO: Does not redirect -> investigate later
+//        resolvedResource = resourceResolver.resolve(request, "/gateway/");
+//        checkRedirectResource(resolvedResource, "http://gbiv.com/", 302);
+        resolvedResource = resourceResolver.resolve(request, "/stories/");
+        checkInternalResource(resolvedResource, "/anecdotes/stories");
+    }
+
+    /**
+     * ATTENTION: this tests showcases an erroneous condition of an endless circular mapping in the /etc/map. When
+     * this test passes this condition is present. After a fix this test must be adjusted.
+     * 
+     * This confirms an issue with the Etc Mapping where a mapping from a node to a child node (here / to /content)
+     * ends up in a endless circular mapping.
+     * The only way to recover from this is to go to the OSGi console and change the /etc/map path in the Resource
+     * Resolver factory.
+     * Either the Etc Mapping discovers this condition and stops it or at least ignores mapping for Composum to allow
+     * the /etc/map to be edited.
+     */
+    @Test
+    public void endless_circular_mapping() throws Exception {
+        buildResource(http.getPath() + "/localhost.8080", http, resourceResolver, resourceProvider, PROP_REDIRECT_EXTERNAL, "/content");
+        refreshMapEntries("/etc/map", true);
+
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for root node to content", commonFactory.getMapEntries().getResolveMaps());
+
+        buildResource("/content/test", null, resourceResolver, resourceProvider);
+        buildResource("/content/content/test", null, resourceResolver, resourceProvider);
+        buildResource("/content/content/content/test", null, resourceResolver, resourceProvider);
+
+        HttpServletRequest request = createRequestFromUrl("http://localhost:8080/");
+        Resource resolvedResource = resourceResolver.resolve(request, "/test.html");
+        checkRedirectResource(resolvedResource, "/content/test.html", 302);
+
+        resolvedResource = resourceResolver.resolve(request, "/content/test.html");
+        checkRedirectResource(resolvedResource, "/content/content/test.html", 302);
+
+        resolvedResource = resourceResolver.resolve(request, "/content/content/test.html");
+        checkRedirectResource(resolvedResource, "/content/content/content/test.html", 302);
+    }
+}
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/SimpleValueMapImpl.java b/src/test/java/org/apache/sling/resourceresolver/impl/SimpleValueMapImpl.java
index f1ed9c1..ef71aa7 100644
--- a/src/test/java/org/apache/sling/resourceresolver/impl/SimpleValueMapImpl.java
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/SimpleValueMapImpl.java
@@ -84,7 +84,11 @@
     public <T> T get(String name, Class<T> type) {
         Object o = delegate.get(name);
         if ( type.equals(String[].class) && ! ( o instanceof String[])) {
-            o = new String[] { String.valueOf(o) };
+            // According to ValueMap if the value cannot be converted it should return null
+            // If 'o' is null this would return String[] {null} instead so we do not convert it here
+            if(o != null) {
+                o = new String[]{String.valueOf(o)};
+            }
         }
         return (T) o;
     }
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/AbstractMappingMapEntriesTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/AbstractMappingMapEntriesTest.java
new file mode 100644
index 0000000..6a5f9e2
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/AbstractMappingMapEntriesTest.java
@@ -0,0 +1,227 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceMetadata;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ResourceUtil;
+import org.apache.sling.api.resource.ValueMap;
+import org.apache.sling.api.resource.path.Path;
+import org.apache.sling.api.wrappers.ValueMapDecorator;
+import org.junit.After;
+import org.junit.Before;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.service.event.EventAdmin;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.Semaphore;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyMap;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+/**
+ * These are tests that are testing the Sling Interpolation Feature (SLING-7768)
+ * on the MapEntries level
+ */
+public abstract class AbstractMappingMapEntriesTest {
+    static final String PROP_REG_EXP = "sling:match";
+
+    @Mock
+    MapConfigurationProvider resourceResolverFactory;
+
+    @Mock
+    BundleContext bundleContext;
+
+    @Mock
+    Bundle bundle;
+
+    @Mock
+    EventAdmin eventAdmin;
+
+    @Mock
+    ResourceResolver resourceResolver;
+
+    MapEntries mapEntries;
+
+    File vanityBloomFilterFile;
+
+    Resource map;
+    Resource http;
+
+    Map<String, Map<String, String>> aliasMap;
+
+    @SuppressWarnings({"unchecked"})
+    @Before
+    public void setup() throws Exception {
+        MockitoAnnotations.initMocks(this);
+
+        List<MapConfigurationProvider.VanityPathConfig> configs = getVanityPathConfigs();
+        vanityBloomFilterFile = new File("target/test-classes/resourcesvanityBloomFilter.txt");
+        when(bundle.getSymbolicName()).thenReturn("TESTBUNDLE");
+        when(bundleContext.getBundle()).thenReturn(bundle);
+        when(bundleContext.getDataFile("vanityBloomFilter.txt")).thenReturn(vanityBloomFilterFile);
+        when(resourceResolverFactory.getServiceResourceResolver(any(Map.class))).thenReturn(resourceResolver);
+        when(resourceResolverFactory.isVanityPathEnabled()).thenReturn(true);
+        when(resourceResolverFactory.getVanityPathConfig()).thenReturn(configs);
+        when(resourceResolverFactory.isOptimizeAliasResolutionEnabled()).thenReturn(true);
+        when(resourceResolverFactory.getObservationPaths()).thenReturn(new Path[] {new Path("/")});
+        when(resourceResolverFactory.getMapRoot()).thenReturn(MapEntries.DEFAULT_MAP_ROOT);
+        when(resourceResolverFactory.getMaxCachedVanityPathEntries()).thenReturn(-1L);
+        when(resourceResolverFactory.isMaxCachedVanityPathEntriesStartup()).thenReturn(true);
+        when(resourceResolver.findResources(anyString(), eq("sql"))).thenReturn(
+            Collections.<Resource> emptySet().iterator());
+
+        map = setupEtcMapResource("/etc", "map");
+        http = setupEtcMapResource("http", map);
+
+        mapEntries = new MapEntries(resourceResolverFactory, bundleContext, eventAdmin);
+
+        final Field aliasMapField = MapEntries.class.getDeclaredField("aliasMap");
+        aliasMapField.setAccessible(true);
+        this.aliasMap = ( Map<String, Map<String, String>>) aliasMapField.get(mapEntries);
+    }
+
+    List<MapConfigurationProvider.VanityPathConfig> getVanityPathConfigs() {
+        return new ArrayList<>();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        vanityBloomFilterFile.delete();
+    }
+
+
+    // -------------------------- private methods ----------
+
+    ValueMap buildValueMap(Object... string) {
+        final Map<String, Object> data = new HashMap<>();
+        for (int i = 0; i < string.length; i = i + 2) {
+            data.put((String) string[i], string[i+1]);
+        }
+        return new ValueMapDecorator(data);
+    }
+
+    Resource getVanityPathResource(final String path) {
+        Resource rsrc = mock(Resource.class);
+        when(rsrc.getPath()).thenReturn(path);
+        when(rsrc.getName()).thenReturn(ResourceUtil.getName(path));
+        when(rsrc.getValueMap()).thenReturn(buildValueMap("sling:vanityPath", "/vanity" + path));
+        return rsrc;
+    }
+
+    Resource setupEtcMapResource(String parentPath, String name, String...valueMapPairs) {
+        return setupEtcMapResource0(parentPath, name, null, valueMapPairs);
+    }
+    Resource setupEtcMapResource(String name, Resource parent, String...valueMapPairs) {
+        return setupEtcMapResource0(null, name, parent, valueMapPairs);
+    }
+    private Resource setupEtcMapResource0(String parentPath, String name, Resource parent, String...valueMapPairs) {
+        Resource resource = mock(Resource.class, withSettings().name(name).extraInterfaces(ResourceDecorator.class));
+        String path = (parent == null ? parentPath : parent.getPath()) + "/" + name;
+        when(resource.getPath()).thenReturn(path);
+        when(resource.getName()).thenReturn(name);
+        ValueMap valueMap = buildValueMap(valueMapPairs);
+        when(resource.getValueMap()).thenReturn(valueMap);
+        when(resource.adaptTo(ValueMap.class)).thenReturn(valueMap);
+        when(resourceResolver.getResource(resource.getPath())).thenReturn(resource);
+        if(parent != null) {
+            List<Resource> childList = ((ResourceDecorator) parent).getChildrenList();
+            childList.add(resource);
+        }
+        final List<Resource> childrenList = new ArrayList<>();
+        when(((ResourceDecorator) resource).getChildrenList()).thenReturn(childrenList);
+        // Delay the children list iterator to make sure all children are added beforehand
+        // Iterators have a modCount that is set when created. Any changes to the underlying list will
+        // change that modCount and the usage of the iterator will fail due to Concurrent Modification Exception
+        when(resource.listChildren()).thenAnswer(new Answer<Iterator<Resource>>() {
+            @Override
+            public Iterator<Resource> answer(InvocationOnMock invocation) throws Throwable {
+                return childrenList.iterator();
+            }
+        });
+        ResourceMetadata resourceMetadata = mock(ResourceMetadata.class);
+        when(resource.getResourceMetadata()).thenReturn(resourceMetadata);
+        doNothing().when(resourceMetadata).setResolutionPath(anyString());
+        doNothing().when(resourceMetadata).setParameterMap(anyMap());
+
+        return resource;
+    }
+
+    DataFuture createDataFuture(ExecutorService pool, final MapEntries mapEntries) {
+
+        Future<Iterator<?>> future = pool.submit(new Callable<Iterator<?>>() {
+            @Override
+            public Iterator<MapEntry> call() throws Exception {
+                return mapEntries.getResolveMapsIterator("http/localhost.8080/target/justVanityPath");
+            }
+        });
+        return new DataFuture(future);
+    }
+
+    void simulateSomewhatSlowSessionOperation(final Semaphore sessionLock) throws InterruptedException {
+        if (!sessionLock.tryAcquire()) {
+            fail("concurrent session access detected");
+        }
+        try{
+            Thread.sleep(1);
+        } finally {
+            sessionLock.release();
+        }
+    }
+
+    /**
+     * Iterator to piggyback the list of Resources onto a Resource Mock
+     * so that we can add children to them and create the iterators after
+     * everything is setup
+     */
+    static interface ResourceDecorator {
+        public List<Resource> getChildrenList();
+    }
+
+    static class DataFuture {
+        public Future<Iterator<?>> future;
+
+        public DataFuture(Future<Iterator<?>> future) {
+            super();
+            this.future = future;
+        }
+    }
+
+}
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/EtcMappingMapEntriesTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/EtcMappingMapEntriesTest.java
new file mode 100644
index 0000000..42bce46
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/EtcMappingMapEntriesTest.java
@@ -0,0 +1,131 @@
+/*
+ * 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.resourceresolver.impl.mapping;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.path.Path;
+import org.apache.sling.resourceresolver.impl.CommonResourceResolverFactoryImpl;
+import org.apache.sling.resourceresolver.impl.ResourceAccessSecurityTracker;
+import org.apache.sling.resourceresolver.impl.ResourceResolverFactoryActivator;
+import org.apache.sling.resourceresolver.impl.ResourceResolverFactoryImpl;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderHandler;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderStorage;
+import org.apache.sling.resourceresolver.impl.providers.ResourceProviderTracker;
+import org.apache.sling.serviceusermapping.ServiceUserMapper;
+import org.apache.sling.spi.resource.provider.ResolveContext;
+import org.apache.sling.spi.resource.provider.ResourceContext;
+import org.apache.sling.spi.resource.provider.ResourceProvider;
+import org.junit.Test;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static org.apache.sling.resourceresolver.impl.MockedResourceResolverImplTest.createRPHandler;
+import static org.apache.sling.resourceresolver.impl.ResourceResolverImpl.PROP_REDIRECT_INTERNAL;
+import static org.apache.sling.resourceresolver.impl.mapping.MapEntries.PROP_REDIRECT_EXTERNAL;
+import static org.apache.sling.resourceresolver.util.MockTestUtil.ExpectedEtcMapping;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+/**
+ * These tests are for the /etc/map setup of the Map Entries when
+ * an /etc/map is present.
+ */
+public class EtcMappingMapEntriesTest extends AbstractMappingMapEntriesTest {
+
+    @Test
+    public void root_node_to_content_mapping() throws Exception {
+        setupEtcMapResource("localhost.8080", http,PROP_REDIRECT_EXTERNAL, "/content/simple-node");
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-node/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for simple node", mapEntries.getResolveMaps());
+    }
+
+    @Test
+    public void match_to_content_mapping() throws Exception {
+        setupEtcMapResource("test-node", http,
+            PROP_REG_EXP, "localhost.8080/",
+            PROP_REDIRECT_EXTERNAL, "/content/simple-match/"
+        );
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/localhost.8080/", "/content/simple-match/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for simple match", mapEntries.getResolveMaps());
+    }
+
+    // The following tests are based on the example from the https://sling.apache.org/documentation/the-sling-engine/mappings-for-resource-resolution.html page
+
+    @Test
+    public void internal_to_external_node_mapping() throws Exception {
+        setupEtcMapResource("example.com.80", http,PROP_REDIRECT_EXTERNAL, "http://www.example.com/");
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping("^http/example.com.80/", "http://www.example.com/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for internal to external based on node", mapEntries.getResolveMaps());
+    }
+
+    @Test
+    public void internal_root_to_content_node_mapping() throws Exception {
+        setupEtcMapResource("www.example.com.80", http,PROP_REDIRECT_INTERNAL, "/example");
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/www.example.com.80/", true, "/example/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for internal root to content", mapEntries.getResolveMaps());
+    }
+
+    @Test
+    public void host_redirect_match_mapping() throws Exception {
+        setupEtcMapResource("any_example.com.80", http,
+            PROP_REG_EXP, ".+\\.example\\.com\\.80",
+            PROP_REDIRECT_EXTERNAL, "http://www.example.com/"
+        );
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping().addEtcMapEntry("^http/.+\\.example\\.com\\.80", false, "http://www.example.com/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for host redirect match mapping", mapEntries.getResolveMaps());
+    }
+
+    @Test
+    public void nested_internal_mixed_mapping() throws Exception {
+        Resource localhost = setupEtcMapResource("localhost_any", http,
+            PROP_REG_EXP, "localhost\\.\\d*",
+            PROP_REDIRECT_INTERNAL, "/content"
+        );
+        setupEtcMapResource("cgi-bin", localhost, PROP_REDIRECT_INTERNAL, "/scripts");
+        setupEtcMapResource("gateway", localhost, PROP_REDIRECT_INTERNAL, "http://gbiv.com");
+        setupEtcMapResource("(stories)", localhost, PROP_REDIRECT_INTERNAL, "/anecdotes/$1");
+
+        mapEntries.doInit();
+        ExpectedEtcMapping expectedEtcMapping = new ExpectedEtcMapping()
+            .addEtcMapEntry("^http/localhost\\.\\d*", true, "/content")
+            .addEtcMapEntry("^http/localhost\\.\\d*/cgi-bin/", true, "/scripts/")
+            .addEtcMapEntry("^http/localhost\\.\\d*/gateway/", true, "http://gbiv.com/")
+            .addEtcMapEntry("^http/localhost\\.\\d*/(stories)/", true, "/anecdotes/$1/");
+        expectedEtcMapping.assertEtcMap("Etc Mapping for nested internal mixed mapping", mapEntries.getResolveMaps());
+    }
+}
diff --git a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/MapEntriesTest.java b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/MapEntriesTest.java
index 8864fb8..5758e49 100644
--- a/src/test/java/org/apache/sling/resourceresolver/impl/mapping/MapEntriesTest.java
+++ b/src/test/java/org/apache/sling/resourceresolver/impl/mapping/MapEntriesTest.java
@@ -63,6 +63,7 @@
 import org.apache.sling.api.wrappers.ValueMapDecorator;
 import org.apache.sling.resourceresolver.impl.ResourceResolverImpl;
 import org.apache.sling.resourceresolver.impl.mapping.MapConfigurationProvider.VanityPathConfig;
+import org.apache.sling.resourceresolver.util.MockTestUtil;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -75,7 +76,7 @@
 import org.osgi.framework.BundleContext;
 import org.osgi.service.event.EventAdmin;
 
-public class MapEntriesTest {
+public class MapEntriesTest extends AbstractMappingMapEntriesTest {
 
     private MapEntries mapEntries;
 
@@ -371,22 +372,6 @@
         assertTrue( mapEntries.getResolveMaps().isEmpty());
     }
 
-    private ValueMap buildValueMap(Object... string) {
-        final Map<String, Object> data = new HashMap<>();
-        for (int i = 0; i < string.length; i = i + 2) {
-            data.put((String) string[i], string[i+1]);
-        }
-        return new ValueMapDecorator(data);
-    }
-
-    private Resource getVanityPathResource(final String path) {
-        Resource rsrc = mock(Resource.class);
-        when(rsrc.getPath()).thenReturn(path);
-        when(rsrc.getName()).thenReturn(ResourceUtil.getName(path));
-        when(rsrc.getValueMap()).thenReturn(buildValueMap("sling:vanityPath", "/vanity" + path));
-        return rsrc;
-    }
-
     @Test
     public void test_vanity_path_registration_include_exclude() throws IOException {
         final String[] validPaths = {"/libs/somewhere", "/libs/a/b", "/foo/a", "/baa/a"};
@@ -2096,39 +2081,4 @@
             }
         }
     }
-
-    // -------------------------- private methods ----------
-    private DataFuture createDataFuture(ExecutorService pool, final MapEntries mapEntries) {
-
-        Future<Iterator<?>> future = pool.submit(new Callable<Iterator<?>>() {
-            @Override
-            public Iterator<MapEntry> call() throws Exception {
-                return mapEntries.getResolveMapsIterator("http/localhost.8080/target/justVanityPath");
-            }
-        });
-        return new DataFuture(future);
-    }
-
-    private void simulateSomewhatSlowSessionOperation(final Semaphore sessionLock) throws InterruptedException {
-        if (!sessionLock.tryAcquire()) {
-            fail("concurrent session access detected");
-        }
-        try{
-            Thread.sleep(1);
-        } finally {
-            sessionLock.release();
-        }
-    }
-
-    // -------------------------- inner classes ------------
-
-    private static class DataFuture {
-        public Future<Iterator<?>> future;
-
-        public DataFuture(Future<Iterator<?>> future) {
-            super();
-            this.future = future;
-        }
-    }
-
 }
\ No newline at end of file
diff --git a/src/test/java/org/apache/sling/resourceresolver/util/MockTestUtil.java b/src/test/java/org/apache/sling/resourceresolver/util/MockTestUtil.java
new file mode 100644
index 0000000..1480397
--- /dev/null
+++ b/src/test/java/org/apache/sling/resourceresolver/util/MockTestUtil.java
@@ -0,0 +1,407 @@
+/*
+ * 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.resourceresolver.util;
+
+import junit.framework.TestCase;
+import org.apache.sling.api.resource.NonExistingResource;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceMetadata;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ValueMap;
+import org.apache.sling.api.wrappers.ValueMapDecorator;
+import org.apache.sling.resourceresolver.impl.SimpleValueMapImpl;
+import org.apache.sling.resourceresolver.impl.helper.RedirectResource;
+import org.apache.sling.resourceresolver.impl.mapping.MapEntry;
+import org.apache.sling.spi.resource.provider.ResolveContext;
+import org.apache.sling.spi.resource.provider.ResourceContext;
+import org.apache.sling.spi.resource.provider.ResourceProvider;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+public class MockTestUtil {
+
+    static final String PROP_SLING_TARGET = "sling:target";
+    static final String PROP_SLING_STATUS = "sling:status";
+
+    public static void checkRedirectResource(Resource redirect, String target, int status) {
+        assertThat("Not a Redirect Resource", redirect, instanceOf(RedirectResource.class));
+        RedirectResource redirectResource = (RedirectResource) redirect;
+        ValueMap values = redirectResource.adaptTo(ValueMap.class);
+        assertEquals("Redirect Target is wrong", target, values.get(PROP_SLING_TARGET, String.class));
+        assertEquals("Redirect Status is wrong", new Integer(status), values.get(PROP_SLING_STATUS, Integer.class));
+    }
+
+    public static void checkNonExistingResource(Resource redirect, String path) {
+        assertThat("Not a Non Existing Resource", redirect, instanceOf(NonExistingResource.class));
+        NonExistingResource nonExistingResource = (NonExistingResource) redirect;
+        if(path != null) {
+            assertEquals("Wrong Path for Non Existing Resource", path, nonExistingResource.getPath());
+        }
+    }
+
+    public static void checkInternalResource(Resource internal, String path) {
+        assertEquals("Wrong Path for Resource", path, internal.getPath());
+    }
+
+    /**
+     * Extract the name from a resource path
+     *
+     * @param fullPath Full / Aboslute path to the resource
+     * @return Name of the resource
+     */
+    public static String getResourceName(String fullPath) {
+        int n = fullPath.lastIndexOf("/");
+        return fullPath.substring(n + 1);
+    }
+
+    /**
+     * Creates a Mock Http Servlet Request
+     * @param url Absolute URL to be used to get the method, host and port
+     * @return Http Servlet Request if the url is valid otherwise null
+     */
+    public static HttpServletRequest createRequestFromUrl(String url) {
+        int index = url.indexOf("://");
+        if(index > 0) {
+            String method = url.substring(0, index);
+            int port = 80;
+            int index2 = url.indexOf(":", index + 3);
+            int index3 = url.indexOf("/", index2 > index ? index2 : index + 3);
+            String host = "";
+            if (index2 > 0) {
+                port = new Integer(url.substring(index2 + 1, index3));
+                host = url.substring(index + 3, index2);
+            } else {
+                if(index3 > 0) {
+                    host = url.substring(index + 3, index3);
+                } else {
+                    host = url.substring(index + 3);
+                }
+            }
+            HttpServletRequest request = mock(HttpServletRequest.class);
+            when(request.getScheme()).thenReturn(method);
+            when(request.getServerName()).thenReturn(host);
+            when(request.getServerPort()).thenReturn(port);
+            return request;
+        }
+        return null;
+    }
+
+    /**
+     * Build a resource with path, parent, provider and resource resolver.
+     *
+     * @param fullPath         Full Path of the Resource
+     * @param parent           Parent of this resource but it can be null
+     * @param resourceResolver Resource Resolver of this resource
+     * @param provider         Resource Provider Instance
+     * @param properties       Key / Value pair for resource properties (the number of strings must be even)
+     * @return Mock Resource able to handle addition of children later on
+     */
+    @SuppressWarnings("unchecked")
+    public static Resource buildResource(String fullPath, Resource parent, ResourceResolver resourceResolver, ResourceProvider<?> provider, String... properties) {
+        if (properties != null && properties.length % 2 != 0) {
+            throw new IllegalArgumentException("List of Resource Properties must be an even number: " + asList(properties));
+        }
+        Resource resource = mock(Resource.class, withSettings().name(getResourceName(fullPath)).extraInterfaces(ResourceChildrenAccessor.class));
+        when(resource.getName()).thenReturn(getResourceName(fullPath));
+        when(resource.getPath()).thenReturn(fullPath);
+        ResourceMetadata resourceMetadata = new ResourceMetadata();
+        when(resource.getResourceMetadata()).thenReturn(resourceMetadata);
+        when(resource.getResourceResolver()).thenReturn(resourceResolver);
+
+        if (parent != null) {
+            List<Resource> childList = ((ResourceChildrenAccessor) parent).getChildrenList();
+            childList.add(resource);
+        }
+        final List<Resource> childrenList = new ArrayList<>();
+        when(((ResourceChildrenAccessor) resource).getChildrenList()).thenReturn(childrenList);
+        // Delay the children list iterator to make sure all children are added beforehand
+        // Iterators have a modCount that is set when created. Any changes to the underlying list will
+        // change that modCount and the usage of the iterator will fail due to Concurrent Modification Exception
+        when(resource.listChildren()).thenAnswer(new Answer<Iterator<Resource>>() {
+            @Override
+            public Iterator<Resource> answer(InvocationOnMock invocation) throws Throwable {
+                return childrenList.iterator();
+            }
+        });
+
+        // register the resource with the provider
+        if (provider != null) {
+            when(provider.listChildren(Mockito.any(ResolveContext.class), Mockito.eq(resource))).thenAnswer(new Answer<Iterator<Resource>>() {
+                @Override
+                public Iterator<Resource> answer(InvocationOnMock invocation) throws Throwable {
+                    return childrenList.iterator();
+                }
+            });
+            when(provider.getResource(Mockito.any(ResolveContext.class), Mockito.eq(fullPath), Mockito.any(ResourceContext.class), Mockito.any(Resource.class))).thenReturn(resource);
+        }
+        if (properties != null) {
+            ValueMap vm = new SimpleValueMapImpl();
+            for (int i = 0; i < properties.length; i += 2) {
+                resourceMetadata.put(properties[i], properties[i + 1]);
+                vm.put(properties[i], properties[i + 1]);
+            }
+            when(resource.getValueMap()).thenReturn(vm);
+            when(resource.adaptTo(Mockito.eq(ValueMap.class))).thenReturn(vm);
+        } else {
+            when(resource.getValueMap()).thenReturn(ValueMapDecorator.EMPTY);
+            when(resource.adaptTo(Mockito.eq(ValueMap.class))).thenReturn(ValueMapDecorator.EMPTY);
+        }
+
+        return resource;
+    }
+
+    /**
+     * Calls a private method that has no parameter like a getter
+     *
+     * @param methodName Name of the method
+     * @param target Target instance
+     * @return Object that is returned from the method call
+     *
+     * @throws UnsupportedOperationException If the call failed because it method is not found, has no access or invocation failed
+     */
+    public static <T> T callInaccessibleMethod(String methodName, Class<T> returnType, Object target) {
+        return callInaccessibleMethod(methodName, returnType, target, new Class[] {}, new Object[] {});
+    }
+
+    /**
+     * Calls a private method that has one parameter like a setter method
+     *
+     * @param methodName Name of the method
+     * @param target Target instance
+     * @param paramsType Parameter Type which cannot be null
+     * @param param Parameter Value
+     * @return Object that is returned from the method call
+     *
+     * @throws UnsupportedOperationException If the call failed because it method is not found, has no access or invocation failed
+     */
+    public static <T> T callInaccessibleMethod(String methodName, Class<T> returnType, Object target, Class paramsType, Object param) {
+        return callInaccessibleMethod(methodName, returnType, target, new Class[] {paramsType}, new Object[] {param});
+    }
+
+    /**
+     * Calls a private method that has none or one parameter like a setter method
+     *
+     * ATTENTION: If parameter types of values is null then both are set to null. Also the length of the arrays must
+     * be the same
+     *
+     * @param methodName Name of the method
+     * @param target Target instance
+     * @param parameterTypes Parameter Types which must not be null
+     * @param parameters Parameter Values which must not be null
+     * @return Object that is returned from the method call
+     *
+     * @throws IllegalArgumentException If the parameter types and values do not match
+     * @throws UnsupportedOperationException If the call failed because it method is not found, has no access or invocation failed
+     */
+    public static <T> T callInaccessibleMethod(String methodName, Class<T> returnType, Object target, Class[] parameterTypes, Object[] parameters) {
+        if(parameterTypes != null && parameters != null) {
+            if(parameters.length != parameterTypes.length) { throw new IllegalArgumentException("Number of Parameter Types and Values were not the same"); }
+        } else {
+            throw new IllegalArgumentException("Parameter Type and Value Array cannot be null");
+        }
+        try {
+            return getInaccessibleMethod(methodName, returnType, target, parameterTypes).call(parameters);
+        } catch (IllegalAccessException e) {
+            throw new UnsupportedOperationException("Failed to access method: " + methodName, e);
+        } catch (InvocationTargetException e) {
+            throw new UnsupportedOperationException("Failed to invoke method: " + methodName, e);
+        }
+    }
+
+    public static <T> MethodWrapper<T> getInaccessibleMethod(String methodName, Class<T> returnType, Object target, Class...parameterTypes) {
+        return new MethodWrapper(methodName, returnType, target, parameterTypes);
+    }
+
+    public static class MethodWrapper<T> {
+        private Method method;
+        private Object target;
+
+        public MethodWrapper(String methodName, Class<T> returnType, Object target, Class[] parameterTypes) {
+            try {
+                this.method = target.getClass().getDeclaredMethod(methodName, parameterTypes);
+                this.method.setAccessible(true);
+                this.target = target;
+                if(returnType == null && !this.method.getReturnType().equals(Void.TYPE)) {
+                    throw new IllegalArgumentException("Return Type is null but method does not return Void but: " + this.method.getReturnType());
+                }
+                if(returnType != null && !returnType.isAssignableFrom(this.method.getReturnType())) {
+                    throw new IllegalArgumentException("Return Type is not assignable to: " + returnType + ", it returns this: " + this.method.getReturnType());
+                }
+            } catch (NoSuchMethodException e) {
+                throw new UnsupportedOperationException("Failed to find method: " + methodName, e);
+            }
+        }
+
+        public T call(Object...parameters) throws InvocationTargetException, IllegalAccessException {
+            return (T) method.invoke(target, parameters);
+        }
+    }
+
+    /**
+     * Sets the value of a private field
+     *
+     * @param fieldName Name of the field to be set
+     * @param target Target instance
+     * @param fieldValue Value to be set
+     *
+     * @throws UnsupportedOperationException If the call failed because it field is not found or has no access
+     */
+    public static void setInaccessibleField(String fieldName, Object target, Object fieldValue) throws NoSuchMethodException {
+        try {
+            getInaccessibleFieldWrapper(fieldName, target, Object.class).set(fieldValue);
+        } catch (IllegalAccessException e) {
+            throw new UnsupportedOperationException("Failed to access field: " + fieldName, e);
+        }
+    }
+
+    public static <T> T getInaccessibleField(String fieldName, Object target, Class<T> type) {
+        try {
+            return getInaccessibleFieldWrapper(fieldName, target, type).get();
+        } catch (IllegalAccessException e) {
+            throw new UnsupportedOperationException("Failed to access field: " + fieldName, e);
+        }
+    }
+
+    public static <T> FieldWrapper<T> getInaccessibleFieldWrapper(String fieldName, Object target, Class<T> type) {
+        try {
+            return new FieldWrapper(fieldName, target, type);
+        } catch (NoSuchFieldException e) {
+            throw new UnsupportedOperationException("Failed to find field: " + fieldName, e);
+        }
+    }
+
+    public static class FieldWrapper<T> {
+        private Field field;
+        private Object target;
+
+        public FieldWrapper(String fieldName, Object target, Class<T> type) throws NoSuchFieldException {
+            this.field = target.getClass().getDeclaredField(fieldName);
+            this.field.setAccessible(true);
+            this.target = target;
+        }
+
+        public void set(T parameter) throws IllegalAccessException {
+            field.set(target, parameter);
+        }
+
+        public T get() throws IllegalAccessException {
+            return (T) field.get(target);
+        }
+    }
+
+    /**
+     * Iterator to piggyback the list of Resources onto a Resource Mock
+     * so that we can add children to them and create the iterators after
+     * everything is setup
+     */
+    static interface ResourceChildrenAccessor {
+        public List<Resource> getChildrenList();
+    }
+
+    /**
+     * Defines the Result of the Etc Mapping for easy testing
+     */
+    public static class ExpectedEtcMapping {
+        List<ExpectedEtcMapEntry> expectedEtcMapEntries = new ArrayList<>();
+
+        public ExpectedEtcMapping() {}
+
+        public ExpectedEtcMapping(String...expectedMapping) {
+            if(expectedMapping.length % 2 != 0) {
+                throw new IllegalArgumentException("Expect an even number of strings with pattern / redirect");
+            }
+            int size = expectedMapping.length / 2;
+            for(int i = 0; i < size; i++ ) {
+                expectedEtcMapEntries.add(new ExpectedEtcMapEntry(expectedMapping[2 * i], expectedMapping[2 * i + 1]));
+            }
+        }
+
+        public ExpectedEtcMapping addEtcMapEntry(String pattern, String redirect) {
+            addEtcMapEntry(pattern, false, redirect);
+            return this;
+        }
+        public ExpectedEtcMapping addEtcMapEntry(String pattern, boolean internal, String redirect) {
+            expectedEtcMapEntries.add(new ExpectedEtcMapEntry(pattern, internal, redirect));
+            return this;
+        }
+
+        public void assertEtcMap(String title, List<MapEntry> mapEntries) {
+            assertEquals("Wrong Number of Mappings for: " + title, expectedEtcMapEntries.size(), mapEntries.size());
+            ArrayList<MapEntry> actual = new ArrayList<>(mapEntries);
+            ArrayList<ExpectedEtcMapEntry> expected = new ArrayList<>(expectedEtcMapEntries);
+            for(MapEntry actualMapEntry: actual) {
+                ExpectedEtcMapEntry expectedFound = null;
+                for(ExpectedEtcMapEntry expectedEtcMapEntry: expected) {
+                    if(expectedEtcMapEntry.pattern.equals(actualMapEntry.getPattern())) {
+                        expectedFound = expectedEtcMapEntry;
+                        break;
+                    }
+                }
+                if(expectedFound == null) {
+                    TestCase.fail("This pattern (" + actualMapEntry.getPattern() + ") is not expected for: " + title);
+                }
+                expectedFound.assertEtcMap(title, actualMapEntry);
+                expected.remove(expectedFound);
+            }
+            for(ExpectedEtcMapEntry expectedEtcMapEntry: expected) {
+                TestCase.fail("Expected Map Entry (" + expectedEtcMapEntry.pattern + ") not provided for: " + title);
+            }
+        }
+    }
+
+    public static class ExpectedEtcMapEntry {
+        private String pattern;
+        private boolean internal;
+        private String redirect;
+
+        public ExpectedEtcMapEntry(String pattern, String redirect) {
+            this(pattern, false, redirect);
+        }
+
+        public ExpectedEtcMapEntry(String pattern, boolean internal, String redirect) {
+            this.pattern = pattern;
+            this.internal = internal;
+            this.redirect = redirect;
+        }
+
+        public void assertEtcMap(String title, MapEntry mapEntry) {
+            assertEquals("Wrong Pattern for " + title, pattern, mapEntry.getPattern());
+            List<String> givenRedirects = new ArrayList<>(Arrays.asList(mapEntry.getRedirect()));
+            assertEquals("Wrong Number of Redirects for: " + title, 1, givenRedirects.size());
+            assertEquals("Wrong Redirect for: " + title, this.redirect, givenRedirects.get(0));
+            assertEquals("Wrong Redirect Type (ext/int) for: " + title, this.internal, mapEntry.isInternal());
+        }
+    }
+}