src/test/java/org/apache/sling/resourcebuilder/impl/ResourceBuilderImplTest.java - sling-org-apache-sling-resourcebuilder - Git at Google

 /*
  * 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.resourcebuilder.impl;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Random;
 import java.util.UUID;

 import org.apache.sling.api.resource.PersistenceException;
 import org.apache.sling.api.resource.Resource;
 import org.apache.sling.api.resource.ResourceResolver;
 import org.apache.sling.api.resource.ResourceUtil;
 import org.apache.sling.commons.mime.MimeTypeService;
 import org.apache.sling.resourcebuilder.api.ResourceBuilder;
 import org.apache.sling.resourcebuilder.test.ResourceAssertions;
 import org.apache.sling.testing.resourceresolver.MockResourceResolverFactory;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;

 @RunWith(MockitoJUnitRunner.class)
 @SuppressWarnings("null")
 public class ResourceBuilderImplTest {

     private String testRootPath;
     private long lastModified;
     private Random random = new Random(System.currentTimeMillis());
     private ResourceAssertions A;

     @Mock
     private MimeTypeService mimeTypeService;

     private ResourceResolver resourceResolver;

     private Resource getTestRoot(String path) throws PersistenceException {
         final Resource root = resourceResolver.resolve("/");
         assertNotNull("Expecting non-null root", root);
         return resourceResolver.create(root, ResourceUtil.getName(path), null);
     }

     private ResourceBuilderImpl getBuilder(String path) throws Exception {
         lastModified = random.nextLong();

         final Resource parent = getTestRoot(path);
         final ResourceBuilderImpl result = new ResourceBuilderImpl(parent, mimeTypeService) {
             @Override
             protected long getLastModified(long userSuppliedValue) {
                 final long now = System.currentTimeMillis();
                 final long superValue = super.getLastModified(-1);
                 final long maxDelta = 60 * 1000L;
                 if(superValue < now || superValue - now > maxDelta) {
                     fail("getLastModified does not seem to use current time as its default value");
                 }

                 if(userSuppliedValue >= 0) {
                     return super.getLastModified(userSuppliedValue);
                 }
                 return lastModified;
             }
         };
         return result;
     }

     @Before
     public void setup() throws Exception {
         when(mimeTypeService.getMimeType(anyString())).thenReturn("application/javascript");
         resourceResolver = new MockResourceResolverFactory().getResourceResolver(null);

         testRootPath = "/" + UUID.randomUUID().toString();
         A = new ResourceAssertions(testRootPath, resourceResolver);
     }

     @After
     public void cleanup() throws PersistenceException {
         final Resource r = resourceResolver.getResource(testRootPath);
         if(r != null) {
             resourceResolver.delete(r);
             resourceResolver.commit();
         }
     }

     @Test
     public void basicResource() throws Exception {
         getBuilder(testRootPath)
             .resource("child", "title", "foo")
             .commit();

         A.assertProperties("child", "title", "foo");
         assertEquals(A.fullPath("child"), A.assertResource("child").getPath());
     }

     @Test
     public void basicResourceWithMap() throws Exception {
         Map<String,Object> props = new HashMap<String,Object>();
         props.put("title", "foo");
         getBuilder(testRootPath)
             .resource("child", props)
             .commit();

         A.assertProperties("child", "title", "foo");
         assertEquals(A.fullPath("child"), A.assertResource("child").getPath());
     }

     @Test
     public void ensureResourceExists() throws Exception {

         class MyResourceBuilder extends ResourceBuilderImpl {
             MyResourceBuilder() {
                 super(resourceResolver.getResource("/"), null);
             }

             Resource r(String path) {
                 return ensureResourceExists(path);
             }
         };
         final MyResourceBuilder b = new MyResourceBuilder();

         assertEquals("/", b.r(null).getPath());
         assertEquals("/", b.r("").getPath());
         assertEquals("/", b.r("/").getPath());
     }

     @Test
     public void deepResource() throws Exception {
         getBuilder(testRootPath)
             .resource("a/b/c", "title", "foo")
             .commit();

         A.assertProperties("a/b/c", "title", "foo");
         assertEquals(A.fullPath("a/b/c"), A.assertResource("a/b/c").getPath());
         A.assertResource("a/b");
         A.assertResource("a");
     }

     @Test
     public void intermediatePrimaryTypes() throws Exception {
         getBuilder(testRootPath)
             .resource("a/b/c")
             .withIntermediatePrimaryType("foo")
             .resource("d/e")
             .withIntermediatePrimaryType(null)
             .resource("f/g")
             .commit();

         A.assertProperties("a/b", ResourceBuilderImpl.JCR_PRIMARYTYPE, "nt:unstructured");
         A.assertProperties("a/b/c/d", ResourceBuilderImpl.JCR_PRIMARYTYPE, "foo");
         A.assertProperties("a/b/c/d/e/f", ResourceBuilderImpl.JCR_PRIMARYTYPE, "nt:unstructured");
     }

     @Test
     public void resetParent() throws Exception {
         getBuilder(testRootPath)
             .resource("a/b/c")
             .siblingsMode()
             .resource("one")
             .resource("two")
             .atParent()  // also sets hierarchyMode
             .resource("d/e")
             .resource("f/g")
             .siblingsMode()
             .resource("three")
             .resource("four")
             .commit();

         A.assertResource("a/b/c");
         A.assertResource("a/b/c/one");
         A.assertResource("a/b/c/two");
         A.assertResource("d/e");
         A.assertResource("d/e/f/g");
         A.assertResource("d/e/f/g/three");
         A.assertResource("d/e/f/g/four");
     }

     @Test
     public void noResetParent() throws Exception {
         getBuilder(testRootPath)
             .resource("a/b/c")
             .resource("d/e")
             .commit();

         A.assertResource("a/b/c");
         A.assertResource("a/b/c/d/e");
     }

     @Test
     public void getParent() throws Exception {
         final Resource parent = getBuilder(testRootPath).getCurrentParent();
         assertNotNull(parent);
         assertEquals(testRootPath, parent.getPath());
     }

     @Test(expected=RuntimeException.class)
     public void missingParentFails() throws Exception {
         new ResourceBuilderImpl(null, null).resource("foo");
     }

     @Test(expected=IllegalArgumentException.class)
     public void aboveParentFails() throws Exception {
         getBuilder(testRootPath).resource("../foo");
     }

     @Test(expected=IllegalArgumentException.class)
     public void aboveParentFailsFile() throws Exception {
         getBuilder(testRootPath).file("../foo.js", null);
     }

     @Test
     public void simpleTree() throws Exception {
         getBuilder(testRootPath)
             .resource("a/b/c", "title", "foo", "count", 21)
             .siblingsMode()
             .resource("1")
             .resource("2")
             .resource("3")
             .hierarchyMode()
             .resource("with")
             .resource("more/here", "it", "worked")
             .resource("deepest", "it", "worked")
             .commit();

         A.assertProperties("a/b/c", "count", 21, "title", "foo");
         A.assertProperties("a/b/c/with/more/here", "it", "worked");
         A.assertResource("a/b/c/with/more/here/deepest");
         A.assertResource("a/b/c/1");
         A.assertResource("a/b/c/2");
         A.assertResource("a/b/c/3");
     }

     @Test
     public void treeWithFiles() throws Exception {
         getBuilder(testRootPath)
             .resource("apps/myapp/components/resource")
             .siblingsMode()
             .file("models.js", getClass().getResourceAsStream("/files/models.js"), "MT1", 42)
             .file("text.html", getClass().getResourceAsStream("/files/text.html"), "MT2", 43)
             .atParent()
             .file("apps/myapp.json", getClass().getResourceAsStream("/files/myapp.json"), "MT3", 44)
             .atParent()
             .resource("apps/content/myapp/resource")
             .atParent()
             .resource("apps/content", "title", "foo")
             .file("myapp.json", getClass().getResourceAsStream("/files/myapp.json"), "MT4", 45)
             .commit()
             ;

         A.assertResource("apps/content/myapp/resource");
         A.assertResource("apps/myapp/components/resource");
         A.assertProperties("apps/content", "title", "foo");

         A.assertFile("apps/myapp/components/resource/models.js",
                 "MT1", "function someJavascriptFunction()", 42L);
         A.assertFile("apps/myapp/components/resource/text.html",
                 "MT2", "This is an html file", 43L);
         A.assertFile("apps/myapp.json",
                 "MT3", "\"sling:resourceType\":\"its/resource/type\"", 44L);
         A.assertFile("apps/content/myapp.json",
                 "MT4", "\"sling:resourceType\":\"its/resource/type\"", 45L);
     }

     @Test
     public void autoMimetype() throws Exception {
         getBuilder(testRootPath)
             .file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
             .commit()
             ;
         A.assertFile("models.js",
                 "application/javascript", "function someJavascriptFunction()", 42L);
     }

     @Test
     public void autoLastModified() throws Exception {
         getBuilder(testRootPath)
             .file("models.js", getClass().getResourceAsStream("/files/models.js"), "MT1", -1)
             .commit()
             ;
         A.assertFile("models.js",
                 "MT1", "function someJavascriptFunction()", lastModified);
     }

     @Test
     public void autoEverything() throws Exception {
         getBuilder(testRootPath)
             .file("a/b/c/models.js", getClass().getResourceAsStream("/files/models.js"))
             .commit()
             ;
         A.assertFile("a/b/c/models.js",
                 "application/javascript", "function someJavascriptFunction()", lastModified);
     }

     @Test(expected=IllegalStateException.class)
     public void duplicatedFileFails() throws Exception {
         getBuilder(testRootPath)
             .siblingsMode()
             .file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
             .file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
             ;
     }

     @Test(expected=IllegalArgumentException.class)
     public void nullDataFails() throws Exception {
         getBuilder(testRootPath)
             .file("models.js", null, null, 42)
             ;
     }

     @Test
     public void forParent() throws PersistenceException {
         new ResourceBuilderFactoryService()
             .forParent(getTestRoot(testRootPath))
             .resource("a/b/c")
             .commit();
         A.assertResource("a/b/c");
     }

     @Test
     public void forResolver() throws PersistenceException {
         new ResourceBuilderFactoryService()
             .forResolver(resourceResolver)
             .resource("d/e/f")
             .commit();

         // Resource is created at root in this case
         A.assertResource("/d/e/f");
     }

     @Test
     public void absolutePath() throws Exception {
         new ResourceBuilderFactoryService()
             .forResolver(resourceResolver)
             .resource("/a/b/c")
             .resource("/a/b/f")
             .resource("/g/h/i")
             .resource("j/l/m")
             .resource("/o/p/q");

         // absolute paths are supported and can be mixed with relative paths
         A.assertResource("/a/b/c");
         A.assertResource("/a/b/f");
         A.assertResource("/g/h/i");
         A.assertResource("/g/h/i/j/l/m");
         A.assertResource("/o/p/q");
     }

     @Test
     public void absolutePathSwitchBackToSiblingMode() throws Exception {
         new ResourceBuilderFactoryService()
             .forResolver(resourceResolver)
             .resource("/a").siblingsMode().resource("a1").resource("a2")
             .resource("/b").siblingsMode().resource("b1").resource("b2")
             .resource("/c").resource("c1").resource("c11");

         // make sure sibling mode is switched back to hierarchy mode when absolute resources is used
         A.assertResource("/a");
         A.assertResource("/a/a1");
         A.assertResource("/a/a2");
         A.assertResource("/b");
         A.assertResource("/b/b1");
         A.assertResource("/b/b2");
         A.assertResource("/c");
         A.assertResource("/c/c1");
         A.assertResource("/c/c1/c11");
     }

     @Test
     public void reuseInstance() throws Exception {
         ResourceBuilder content = new ResourceBuilderFactoryService()
                 .forResolver(resourceResolver)
                 .resource("/content");
         content.resource("a");
         content.resource("b/c");
         content.resource("/test")
                 .siblingsMode()
                 .resource("1")
                 .resource("2");

         A.assertResource("/content/a");
         A.assertResource("/content/b/c");
         A.assertResource("/test");
         A.assertResource("/test/1");
         A.assertResource("/test/2");
     }

 }
	/*
	* 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.resourcebuilder.impl;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.fail;
	import static org.mockito.ArgumentMatchers.anyString;
	import static org.mockito.Mockito.when;

	import java.util.HashMap;
	import java.util.Map;
	import java.util.Random;
	import java.util.UUID;

	import org.apache.sling.api.resource.PersistenceException;
	import org.apache.sling.api.resource.Resource;
	import org.apache.sling.api.resource.ResourceResolver;
	import org.apache.sling.api.resource.ResourceUtil;
	import org.apache.sling.commons.mime.MimeTypeService;
	import org.apache.sling.resourcebuilder.api.ResourceBuilder;
	import org.apache.sling.resourcebuilder.test.ResourceAssertions;
	import org.apache.sling.testing.resourceresolver.MockResourceResolverFactory;
	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.Mock;
	import org.mockito.junit.MockitoJUnitRunner;

	@RunWith(MockitoJUnitRunner.class)
	@SuppressWarnings("null")
	public class ResourceBuilderImplTest {

	private String testRootPath;
	private long lastModified;
	private Random random = new Random(System.currentTimeMillis());
	private ResourceAssertions A;

	@Mock
	private MimeTypeService mimeTypeService;

	private ResourceResolver resourceResolver;

	private Resource getTestRoot(String path) throws PersistenceException {
	final Resource root = resourceResolver.resolve("/");
	assertNotNull("Expecting non-null root", root);
	return resourceResolver.create(root, ResourceUtil.getName(path), null);
	}

	private ResourceBuilderImpl getBuilder(String path) throws Exception {
	lastModified = random.nextLong();

	final Resource parent = getTestRoot(path);
	final ResourceBuilderImpl result = new ResourceBuilderImpl(parent, mimeTypeService) {
	@Override
	protected long getLastModified(long userSuppliedValue) {
	final long now = System.currentTimeMillis();
	final long superValue = super.getLastModified(-1);
	final long maxDelta = 60 * 1000L;
	if(superValue < now \|\| superValue - now > maxDelta) {
	fail("getLastModified does not seem to use current time as its default value");
	}

	if(userSuppliedValue >= 0) {
	return super.getLastModified(userSuppliedValue);
	}
	return lastModified;
	}
	};
	return result;
	}

	@Before
	public void setup() throws Exception {
	when(mimeTypeService.getMimeType(anyString())).thenReturn("application/javascript");
	resourceResolver = new MockResourceResolverFactory().getResourceResolver(null);

	testRootPath = "/" + UUID.randomUUID().toString();
	A = new ResourceAssertions(testRootPath, resourceResolver);
	}

	@After
	public void cleanup() throws PersistenceException {
	final Resource r = resourceResolver.getResource(testRootPath);
	if(r != null) {
	resourceResolver.delete(r);
	resourceResolver.commit();
	}
	}

	@Test
	public void basicResource() throws Exception {
	getBuilder(testRootPath)
	.resource("child", "title", "foo")
	.commit();

	A.assertProperties("child", "title", "foo");
	assertEquals(A.fullPath("child"), A.assertResource("child").getPath());
	}

	@Test
	public void basicResourceWithMap() throws Exception {
	Map<String,Object> props = new HashMap<String,Object>();
	props.put("title", "foo");
	getBuilder(testRootPath)
	.resource("child", props)
	.commit();

	A.assertProperties("child", "title", "foo");
	assertEquals(A.fullPath("child"), A.assertResource("child").getPath());
	}

	@Test
	public void ensureResourceExists() throws Exception {

	class MyResourceBuilder extends ResourceBuilderImpl {
	MyResourceBuilder() {
	super(resourceResolver.getResource("/"), null);
	}

	Resource r(String path) {
	return ensureResourceExists(path);
	}
	};
	final MyResourceBuilder b = new MyResourceBuilder();

	assertEquals("/", b.r(null).getPath());
	assertEquals("/", b.r("").getPath());
	assertEquals("/", b.r("/").getPath());
	}

	@Test
	public void deepResource() throws Exception {
	getBuilder(testRootPath)
	.resource("a/b/c", "title", "foo")
	.commit();

	A.assertProperties("a/b/c", "title", "foo");
	assertEquals(A.fullPath("a/b/c"), A.assertResource("a/b/c").getPath());
	A.assertResource("a/b");
	A.assertResource("a");
	}

	@Test
	public void intermediatePrimaryTypes() throws Exception {
	getBuilder(testRootPath)
	.resource("a/b/c")
	.withIntermediatePrimaryType("foo")
	.resource("d/e")
	.withIntermediatePrimaryType(null)
	.resource("f/g")
	.commit();

	A.assertProperties("a/b", ResourceBuilderImpl.JCR_PRIMARYTYPE, "nt:unstructured");
	A.assertProperties("a/b/c/d", ResourceBuilderImpl.JCR_PRIMARYTYPE, "foo");
	A.assertProperties("a/b/c/d/e/f", ResourceBuilderImpl.JCR_PRIMARYTYPE, "nt:unstructured");
	}

	@Test
	public void resetParent() throws Exception {
	getBuilder(testRootPath)
	.resource("a/b/c")
	.siblingsMode()
	.resource("one")
	.resource("two")
	.atParent() // also sets hierarchyMode
	.resource("d/e")
	.resource("f/g")
	.siblingsMode()
	.resource("three")
	.resource("four")
	.commit();

	A.assertResource("a/b/c");
	A.assertResource("a/b/c/one");
	A.assertResource("a/b/c/two");
	A.assertResource("d/e");
	A.assertResource("d/e/f/g");
	A.assertResource("d/e/f/g/three");
	A.assertResource("d/e/f/g/four");
	}

	@Test
	public void noResetParent() throws Exception {
	getBuilder(testRootPath)
	.resource("a/b/c")
	.resource("d/e")
	.commit();

	A.assertResource("a/b/c");
	A.assertResource("a/b/c/d/e");
	}

	@Test
	public void getParent() throws Exception {
	final Resource parent = getBuilder(testRootPath).getCurrentParent();
	assertNotNull(parent);
	assertEquals(testRootPath, parent.getPath());
	}

	@Test(expected=RuntimeException.class)
	public void missingParentFails() throws Exception {
	new ResourceBuilderImpl(null, null).resource("foo");
	}

	@Test(expected=IllegalArgumentException.class)
	public void aboveParentFails() throws Exception {
	getBuilder(testRootPath).resource("../foo");
	}

	@Test(expected=IllegalArgumentException.class)
	public void aboveParentFailsFile() throws Exception {
	getBuilder(testRootPath).file("../foo.js", null);
	}

	@Test
	public void simpleTree() throws Exception {
	getBuilder(testRootPath)
	.resource("a/b/c", "title", "foo", "count", 21)
	.siblingsMode()
	.resource("1")
	.resource("2")
	.resource("3")
	.hierarchyMode()
	.resource("with")
	.resource("more/here", "it", "worked")
	.resource("deepest", "it", "worked")
	.commit();

	A.assertProperties("a/b/c", "count", 21, "title", "foo");
	A.assertProperties("a/b/c/with/more/here", "it", "worked");
	A.assertResource("a/b/c/with/more/here/deepest");
	A.assertResource("a/b/c/1");
	A.assertResource("a/b/c/2");
	A.assertResource("a/b/c/3");
	}

	@Test
	public void treeWithFiles() throws Exception {
	getBuilder(testRootPath)
	.resource("apps/myapp/components/resource")
	.siblingsMode()
	.file("models.js", getClass().getResourceAsStream("/files/models.js"), "MT1", 42)
	.file("text.html", getClass().getResourceAsStream("/files/text.html"), "MT2", 43)
	.atParent()
	.file("apps/myapp.json", getClass().getResourceAsStream("/files/myapp.json"), "MT3", 44)
	.atParent()
	.resource("apps/content/myapp/resource")
	.atParent()
	.resource("apps/content", "title", "foo")
	.file("myapp.json", getClass().getResourceAsStream("/files/myapp.json"), "MT4", 45)
	.commit()
	;

	A.assertResource("apps/content/myapp/resource");
	A.assertResource("apps/myapp/components/resource");
	A.assertProperties("apps/content", "title", "foo");

	A.assertFile("apps/myapp/components/resource/models.js",
	"MT1", "function someJavascriptFunction()", 42L);
	A.assertFile("apps/myapp/components/resource/text.html",
	"MT2", "This is an html file", 43L);
	A.assertFile("apps/myapp.json",
	"MT3", "\"sling:resourceType\":\"its/resource/type\"", 44L);
	A.assertFile("apps/content/myapp.json",
	"MT4", "\"sling:resourceType\":\"its/resource/type\"", 45L);
	}

	@Test
	public void autoMimetype() throws Exception {
	getBuilder(testRootPath)
	.file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
	.commit()
	;
	A.assertFile("models.js",
	"application/javascript", "function someJavascriptFunction()", 42L);
	}

	@Test
	public void autoLastModified() throws Exception {
	getBuilder(testRootPath)
	.file("models.js", getClass().getResourceAsStream("/files/models.js"), "MT1", -1)
	.commit()
	;
	A.assertFile("models.js",
	"MT1", "function someJavascriptFunction()", lastModified);
	}

	@Test
	public void autoEverything() throws Exception {
	getBuilder(testRootPath)
	.file("a/b/c/models.js", getClass().getResourceAsStream("/files/models.js"))
	.commit()
	;
	A.assertFile("a/b/c/models.js",
	"application/javascript", "function someJavascriptFunction()", lastModified);
	}

	@Test(expected=IllegalStateException.class)
	public void duplicatedFileFails() throws Exception {
	getBuilder(testRootPath)
	.siblingsMode()
	.file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
	.file("models.js", getClass().getResourceAsStream("/files/models.js"), null, 42)
	;
	}

	@Test(expected=IllegalArgumentException.class)
	public void nullDataFails() throws Exception {
	getBuilder(testRootPath)
	.file("models.js", null, null, 42)
	;
	}

	@Test
	public void forParent() throws PersistenceException {
	new ResourceBuilderFactoryService()
	.forParent(getTestRoot(testRootPath))
	.resource("a/b/c")
	.commit();
	A.assertResource("a/b/c");
	}

	@Test
	public void forResolver() throws PersistenceException {
	new ResourceBuilderFactoryService()
	.forResolver(resourceResolver)
	.resource("d/e/f")
	.commit();

	// Resource is created at root in this case
	A.assertResource("/d/e/f");
	}

	@Test
	public void absolutePath() throws Exception {
	new ResourceBuilderFactoryService()
	.forResolver(resourceResolver)
	.resource("/a/b/c")
	.resource("/a/b/f")
	.resource("/g/h/i")
	.resource("j/l/m")
	.resource("/o/p/q");

	// absolute paths are supported and can be mixed with relative paths
	A.assertResource("/a/b/c");
	A.assertResource("/a/b/f");
	A.assertResource("/g/h/i");
	A.assertResource("/g/h/i/j/l/m");
	A.assertResource("/o/p/q");
	}

	@Test
	public void absolutePathSwitchBackToSiblingMode() throws Exception {
	new ResourceBuilderFactoryService()
	.forResolver(resourceResolver)
	.resource("/a").siblingsMode().resource("a1").resource("a2")
	.resource("/b").siblingsMode().resource("b1").resource("b2")
	.resource("/c").resource("c1").resource("c11");

	// make sure sibling mode is switched back to hierarchy mode when absolute resources is used
	A.assertResource("/a");
	A.assertResource("/a/a1");
	A.assertResource("/a/a2");
	A.assertResource("/b");
	A.assertResource("/b/b1");
	A.assertResource("/b/b2");
	A.assertResource("/c");
	A.assertResource("/c/c1");
	A.assertResource("/c/c1/c11");
	}

	@Test
	public void reuseInstance() throws Exception {
	ResourceBuilder content = new ResourceBuilderFactoryService()
	.forResolver(resourceResolver)
	.resource("/content");
	content.resource("a");
	content.resource("b/c");
	content.resource("/test")
	.siblingsMode()
	.resource("1")
	.resource("2");

	A.assertResource("/content/a");
	A.assertResource("/content/b/c");
	A.assertResource("/test");
	A.assertResource("/test/1");
	A.assertResource("/test/2");
	}

	}