Added: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/FunctionIndexProcessorTest.java
URL: 
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/FunctionIndexProcessorTest.java?rev=1828972&view=auto
==============================================================================
--- 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/FunctionIndexProcessorTest.java
 (added)
+++ 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/FunctionIndexProcessorTest.java
 Thu Apr 12 11:46:17 2018
@@ -0,0 +1,113 @@
+/*
+ * 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.jackrabbit.oak.plugins.index.search.util;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class FunctionIndexProcessorTest {
+    
+    @Test
+    public void getProperties() {
+        assertEquals(
+                "[a, test/b, test/:name]",
+                Arrays.toString(
+                FunctionIndexProcessor.getProperties(new String[] { "function",
+                        "multiply", "@a", "add", "@test/b", "@test/:name" })));
+    }
+    
+    @Test
+    public void xpath() {
+        checkConvert(
+                "fn:upper-case(@data)", 
+                "function*upper*@data");
+        checkConvert(
+                "fn:lower-case(test/@data)", 
+                "function*lower*@test/data");
+        checkConvert(
+                "fn:lower-case(fn:name())", 
+                "function*lower*@:name");        
+        checkConvert(
+                "fn:lower-case(fn:local-name())", 
+                "function*lower*@:localname");
+        checkConvert(
+                "fn:string-length(test/@data)", 
+                "function*length*@test/data");
+        checkConvert(
+                "fn:string-length(fn:name())", 
+                "function*length*@:name");
+        checkConvert(
+                "fn:lower-case(fn:upper-case(test/@data))", 
+                "function*lower*upper*@test/data");
+        checkConvert("fn:coalesce(jcr:content/@foo2, jcr:content/@foo)",
+                "function*coalesce*@jcr:content/foo2*@jcr:content/foo");
+        
checkConvert("fn:coalesce(jcr:content/@foo2,fn:lower-case(jcr:content/@foo))",
+                "function*coalesce*@jcr:content/foo2*lower*@jcr:content/foo");
+        
checkConvert("fn:coalesce(jcr:content/@foo2,fn:coalesce(jcr:content/@foo, 
fn:lower-case(fn:name())))",
+                
"function*coalesce*@jcr:content/foo2*coalesce*@jcr:content/foo*lower*@:name");
+        
checkConvert("fn:coalesce(fn:coalesce(jcr:content/@foo2,jcr:content/@foo), 
fn:coalesce(@a:b, @c:d))",
+                
"function*coalesce*coalesce*@jcr:content/foo2*@jcr:content/foo*coalesce*@a:b*@c:d");
+    }
+
+    @Test
+    public void sql2() {
+        checkConvert(
+                "upper([data])", 
+                "function*upper*@data");
+        checkConvert(
+                "lower([test/data])", 
+                "function*lower*@test/data");
+        checkConvert(
+                "lower(name())", 
+                "function*lower*@:name");
+        checkConvert(
+                "lower(localname())", 
+                "function*lower*@:localname");
+        checkConvert(
+                "length([test/data])", 
+                "function*length*@test/data");
+        checkConvert(
+                "length(name())", 
+                "function*length*@:name");
+        checkConvert(
+                "lower(upper([test/data]))", 
+                "function*lower*upper*@test/data");
+        // the ']' character is escaped as ']]'
+        checkConvert(
+                "[strange[0]]]", 
+                "function*@strange[0]");
+        checkConvert("coalesce([jcr:content/foo2],[jcr:content/foo])",
+                "function*coalesce*@jcr:content/foo2*@jcr:content/foo");
+        checkConvert("coalesce([jcr:content/foo2], lower([jcr:content/foo]))",
+                "function*coalesce*@jcr:content/foo2*lower*@jcr:content/foo");
+        checkConvert("coalesce([jcr:content/foo2] , 
coalesce([jcr:content/foo],lower(name())))",
+                
"function*coalesce*@jcr:content/foo2*coalesce*@jcr:content/foo*lower*@:name");
+        checkConvert("coalesce(coalesce([jcr:content/foo2],[jcr:content/foo]), 
coalesce([a:b], [c:d]))",
+                
"function*coalesce*coalesce*@jcr:content/foo2*@jcr:content/foo*coalesce*@a:b*@c:d");
+    }
+
+    private static void checkConvert(String function, String 
expectedPolishNotation) {
+        String p = FunctionIndexProcessor.convertToPolishNotation(function);
+        assertEquals(expectedPolishNotation, p);
+    }
+
+}

Propchange: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/FunctionIndexProcessorTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/IndexDefinitionBuilderTest.java
URL: 
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/IndexDefinitionBuilderTest.java?rev=1828972&view=auto
==============================================================================
--- 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/IndexDefinitionBuilderTest.java
 (added)
+++ 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/IndexDefinitionBuilderTest.java
 Thu Apr 12 11:46:17 2018
@@ -0,0 +1,318 @@
+/*
+ * 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.jackrabbit.oak.plugins.index.search.util;
+
+import java.util.Iterator;
+
+import org.apache.jackrabbit.oak.api.PropertyState;
+import org.apache.jackrabbit.oak.api.Root;
+import org.apache.jackrabbit.oak.api.Tree;
+import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.core.ImmutableRoot;
+import org.apache.jackrabbit.oak.plugins.index.IndexConstants;
+import org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants;
+import org.apache.jackrabbit.oak.plugins.tree.factories.TreeFactory;
+import org.apache.jackrabbit.oak.spi.filter.PathFilter;
+import org.apache.jackrabbit.oak.spi.state.NodeBuilder;
+import org.apache.jackrabbit.oak.spi.state.NodeState;
+import org.apache.jackrabbit.oak.spi.state.NodeStateUtils;
+import org.junit.After;
+import org.junit.Test;
+
+import static java.util.Arrays.asList;
+import static 
org.apache.jackrabbit.oak.plugins.index.IndexConstants.REINDEX_PROPERTY_NAME;
+import static 
org.apache.jackrabbit.oak.plugins.index.search.FulltextIndexConstants.AGGREGATES;
+import static 
org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState.EMPTY_NODE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class IndexDefinitionBuilderTest {
+    private IndexDefinitionBuilder builder = new IndexDefinitionBuilder();
+    private NodeBuilder nodeBuilder = EMPTY_NODE.builder();
+
+    @After
+    public void dumpState(){
+        System.out.println(NodeStateUtils.toString(builder.build()));
+    }
+
+    @Test
+    public void defaultvSetup() throws Exception{
+        NodeState state = builder.build();
+        assertEquals("async", state.getString("async"));
+        assertEquals("fulltext", state.getString("type"));
+    }
+
+    @Test
+    public void indexRule() throws Exception{
+        builder.includedPaths("/a", "/b");
+        builder.queryPaths("/c", "/d");
+        builder.supersedes("/e", "/f");
+        builder.indexRule("nt:base")
+                    .property("foo")
+                        .ordered()
+                .enclosingRule()
+                    .property("bar")
+                        .analyzed()
+                        .propertyIndex()
+                .enclosingRule()
+                    .property("baz")
+                    .propertyIndex();
+
+        NodeState state = builder.build();
+        assertTrue(state.getChildNode("indexRules").exists());
+        
assertTrue(state.getChildNode("indexRules").getChildNode("nt:base").exists());
+        assertEquals(asList("/a", "/b"), 
state.getProperty(PathFilter.PROP_INCLUDED_PATHS).getValue(Type.STRINGS));
+        assertEquals(asList("/c", "/d"), 
state.getProperty(IndexConstants.QUERY_PATHS).getValue(Type.STRINGS));
+        assertEquals(asList("/e", "/f"), 
state.getProperty(IndexConstants.SUPERSEDED_INDEX_PATHS).getValue(Type.STRINGS));
+    }
+
+    @Test
+    public void propertyDefIndexPropertySetIndexFalse() throws Exception {
+        builder.indexRule("nt:base")
+                .property("foo")
+                .disable();
+
+        PropertyState state = builder.build().
+                getChildNode("indexRules").
+                getChildNode("nt:base").
+                getChildNode("properties").
+                getChildNode("foo").
+                getProperty("index");
+
+        assertNotNull("index property must exist", state);
+        assertFalse("Incorrect default value of index property", 
state.getValue(Type.BOOLEAN));
+    }
+
+    @Test
+    public void aggregates() throws Exception{
+        builder.aggregateRule("cq:Page").include("jcr:content").relativeNode();
+        builder.aggregateRule("dam:Asset", "*", "*/*");
+
+        NodeState state = builder.build();
+        assertTrue(state.getChildNode("aggregates").exists());
+        
assertTrue(state.getChildNode("aggregates").getChildNode("dam:Asset").exists());
+        
assertTrue(state.getChildNode("aggregates").getChildNode("cq:Page").exists());
+    }
+
+    @Test
+    public void duplicatePropertyName() throws Exception{
+        builder.indexRule("nt:base")
+                    .property("foo")
+                        .ordered()
+                .enclosingRule()
+                    .property("jcr:content/foo")
+                        .analyzed()
+                        .propertyIndex()
+                .enclosingRule()
+                    .property("metadata/content/foo")
+                        .propertyIndex();
+
+        NodeState state = builder.build();
+        assertTrue(state.getChildNode("indexRules").exists());
+        
assertTrue(state.getChildNode("indexRules").getChildNode("nt:base").exists());
+        assertEquals(3, 
state.getChildNode("indexRules").getChildNode("nt:base")
+                .getChildNode("properties").getChildNodeCount(10));
+    }
+
+    @Test
+    public void ruleOrder() throws Exception{
+        builder.indexRule("nt:unstructured");
+        builder.indexRule("nt:base");
+
+        Tree tree = TreeFactory.createTree(EMPTY_NODE.builder());
+        builder.build(tree);
+
+        //Assert the order
+        Iterator<Tree> children = 
tree.getChild("indexRules").getChildren().iterator();
+        assertEquals("nt:unstructured", children.next().getName());
+        assertEquals("nt:base", children.next().getName());
+    }
+
+    @Test
+    public void regexProperty() throws Exception{
+        builder.indexRule("nt:base")
+                .property(FulltextIndexConstants.REGEX_ALL_PROPS, true);
+
+        NodeState state = builder.build();
+        assertTrue(NodeStateUtils.getNode(state, 
"indexRules/nt:base/properties/prop")
+                .getBoolean(FulltextIndexConstants.PROP_IS_REGEX));
+    }
+
+    @Test
+    public void mergeExisting() throws Exception{
+        nodeBuilder.setProperty("foo", "bar");
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+
+        NodeState state = builder.build();
+        assertEquals("bar", state.getString("foo"));
+        assertEquals("async", state.getString("async"));
+    }
+
+    @Test
+    public void mergeExisting_IndexRule() throws Exception{
+        builder.indexRule("nt:unstructured").property("foo").propertyIndex();
+
+        nodeBuilder = builder.build().builder();
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+
+        assertTrue(builder.hasIndexRule("nt:unstructured"));
+        assertFalse(builder.hasIndexRule("nt:base"));
+
+        builder.indexRule("nt:unstructured").property("bar").propertyIndex();
+        builder.indexRule("nt:base");
+
+        
assertTrue(builder.indexRule("nt:unstructured").hasPropertyRule("foo"));
+        
assertTrue(builder.indexRule("nt:unstructured").hasPropertyRule("bar"));
+    }
+
+    @Test
+    public void mergeExisting_Aggregates() throws Exception{
+        builder.aggregateRule("foo").include("/path1");
+        builder.aggregateRule("foo").include("/path2");
+
+        nodeBuilder = builder.build().builder();
+
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+
+        builder.aggregateRule("foo").include("/path1");
+        builder.aggregateRule("foo").include("/path3");
+
+        NodeState state = builder.build();
+        assertEquals(3, 
state.getChildNode(AGGREGATES).getChildNode("foo").getChildNodeCount(100));
+    }
+
+    @Test
+    public void noReindexIfNoChange() throws Exception{
+        builder.includedPaths("/a", "/b");
+        builder.indexRule("nt:base")
+                .property("foo")
+                .ordered();
+
+        nodeBuilder = builder.build().builder();
+        nodeBuilder.setProperty(REINDEX_PROPERTY_NAME, false);
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+        builder.includedPaths("/a", "/b");
+
+        assertFalse(builder.isReindexRequired());
+        NodeState state = builder.build();
+        assertFalse(state.getBoolean(REINDEX_PROPERTY_NAME));
+
+
+        NodeState baseState = builder.build();
+        nodeBuilder = baseState.builder();
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+        builder.indexRule("nt:file");
+
+        assertTrue(builder.isReindexRequired());
+        state = builder.build();
+        assertTrue(state.getBoolean(REINDEX_PROPERTY_NAME));
+
+        builder = new IndexDefinitionBuilder(baseState.builder(), false);
+        builder.indexRule("nt:file");
+        assertTrue(builder.isReindexRequired());
+        state = builder.build();
+        assertTrue(builder.isReindexRequired());
+        assertFalse(state.getBoolean(REINDEX_PROPERTY_NAME));
+    }
+
+    @Test
+    public void reindexAndAsyncFlagChange() throws Exception{
+        builder.async("async", IndexConstants.INDEXING_MODE_NRT);
+
+        nodeBuilder = builder.build().builder();
+        nodeBuilder.setProperty(REINDEX_PROPERTY_NAME, false);
+
+        NodeState oldState = nodeBuilder.getNodeState();
+
+        builder = new IndexDefinitionBuilder(nodeBuilder);
+        builder.async("async", IndexConstants.INDEXING_MODE_SYNC);
+        assertFalse(builder.build().getBoolean(REINDEX_PROPERTY_NAME));
+
+        builder = new IndexDefinitionBuilder(oldState.builder());
+        builder.async("fulltext-async", IndexConstants.INDEXING_MODE_SYNC);
+        assertTrue(builder.build().getBoolean(REINDEX_PROPERTY_NAME));
+    }
+
+    @Test
+    public void propRuleCustomName() throws Exception{
+        builder.indexRule("nt:base").property("foo").property("bar");
+        builder.indexRule("nt:base").property("fooProp", "foo2");
+        builder.indexRule("nt:base").property("fooProp", "foo2");
+
+        Root idx = new ImmutableRoot(builder.build());
+        
assertTrue(idx.getTree("/indexRules/nt:base/properties/fooProp").exists());
+        assertTrue(idx.getTree("/indexRules/nt:base/properties/bar").exists());
+        assertTrue(idx.getTree("/indexRules/nt:base/properties/foo").exists());
+    }
+
+    @Test
+    public void typeNotChangedIfSet() throws Exception{
+        NodeState state = builder.build();
+        assertEquals("fulltext", state.getString("type"));
+
+        NodeBuilder updated = state.builder();
+        updated.setProperty("type", "disabled");
+        IndexDefinitionBuilder newBuilder = new 
IndexDefinitionBuilder(updated);
+
+        NodeState updatedState = newBuilder.build();
+        assertEquals("disabled", updatedState.getString("type"));
+
+        //Type other than 'disabled' would be reset
+        updated.setProperty("type", "foo");
+        assertEquals("fulltext", new 
IndexDefinitionBuilder(updated).build().getString("type"));
+    }
+
+    @Test
+    public void nodeTypeIndex() throws Exception{
+        builder.nodeTypeIndex();
+        builder.indexRule("nt:file");
+
+        NodeState state = builder.build();
+        assertTrue(state.getChildNode("indexRules").exists());
+        NodeState ntFileRule = 
state.getChildNode("indexRules").getChildNode("nt:file");
+        assertTrue(ntFileRule.exists());
+        
assertTrue(state.getBoolean(FulltextIndexConstants.PROP_INDEX_NODE_TYPE));
+        assertFalse(ntFileRule.getBoolean(FulltextIndexConstants.PROP_SYNC));
+    }
+
+    @Test
+    public void nodeTypeIndexSync() throws Exception{
+        builder.nodeTypeIndex();
+        builder.indexRule("nt:file").sync();
+
+        NodeState state = builder.build();
+        assertTrue(state.getChildNode("indexRules").exists());
+        NodeState ntFileRule = 
state.getChildNode("indexRules").getChildNode("nt:file");
+        assertTrue(ntFileRule.exists());
+        
assertTrue(state.getBoolean(FulltextIndexConstants.PROP_INDEX_NODE_TYPE));
+        assertTrue(ntFileRule.getBoolean(FulltextIndexConstants.PROP_SYNC));
+    }
+
+    @Test
+    public void noPropertiesNodeForEmptyRule() throws Exception{
+        builder.nodeTypeIndex();
+        builder.indexRule("nt:file").sync();
+
+        NodeState state = builder.build();
+        assertFalse(NodeStateUtils.getNode(state, 
"/indexRules/nt:file/properties").exists());
+    }
+}
\ No newline at end of file

Propchange: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/IndexDefinitionBuilderTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/NodeStateCopyUtilsTest.java
URL: 
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/NodeStateCopyUtilsTest.java?rev=1828972&view=auto
==============================================================================
--- 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/NodeStateCopyUtilsTest.java
 (added)
+++ 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/NodeStateCopyUtilsTest.java
 Thu Apr 12 11:46:17 2018
@@ -0,0 +1,198 @@
+/*
+ * 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.jackrabbit.oak.plugins.index.search.util;
+
+import java.io.InputStream;
+import java.util.Calendar;
+import java.util.Iterator;
+
+import javax.jcr.Node;
+import javax.jcr.Repository;
+import javax.jcr.Session;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.jackrabbit.JcrConstants;
+import org.apache.jackrabbit.api.JackrabbitRepository;
+import org.apache.jackrabbit.oak.api.Tree;
+import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.jcr.Jcr;
+import org.apache.jackrabbit.oak.plugins.memory.ArrayBasedBlob;
+import org.apache.jackrabbit.oak.plugins.tree.factories.TreeFactory;
+import org.apache.jackrabbit.oak.spi.security.OpenSecurityProvider;
+import org.apache.jackrabbit.oak.spi.state.NodeBuilder;
+import org.apache.jackrabbit.util.ISO8601;
+import org.junit.After;
+import org.junit.Test;
+
+import static java.util.Arrays.asList;
+import static 
org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState.EMPTY_NODE;
+import static 
org.apache.jackrabbit.oak.spi.nodetype.NodeTypeConstants.NT_OAK_UNSTRUCTURED;
+import static org.junit.Assert.assertEquals;
+
+public class NodeStateCopyUtilsTest {
+    private NodeBuilder builder = EMPTY_NODE.builder();
+    private Repository repository;
+
+    @After
+    public void cleanup(){
+        if (repository instanceof JackrabbitRepository) {
+            ((JackrabbitRepository) repository).shutdown();
+        }
+    }
+
+    @Test
+    public void copyUnordered() throws Exception{
+        builder.setProperty("foo", "x");
+        builder.child("a").setProperty("foo", "y");
+        builder.child("b").setProperty("foo", "z");
+        builder.child("a").child("c").setProperty("foo", "acx");
+
+        Tree tree = TreeFactory.createTree(EMPTY_NODE.builder());
+        NodeStateCopyUtils.copyToTree(builder.getNodeState(), tree);
+
+        assertEquals("x", tree.getProperty("foo").getValue(Type.STRING));
+        assertEquals(2, tree.getChildrenCount(100));
+        assertEquals("y", 
tree.getChild("a").getProperty("foo").getValue(Type.STRING));
+        assertEquals("z", 
tree.getChild("b").getProperty("foo").getValue(Type.STRING));
+        assertEquals("acx", 
tree.getChild("a").getChild("c").getProperty("foo").getValue(Type.STRING));
+    }
+
+    @Test
+    public void copyOrdered() throws Exception{
+        NodeBuilder testBuilder = EMPTY_NODE.builder();
+        Tree srcTree = TreeFactory.createTree(testBuilder);
+        srcTree.setOrderableChildren(true);
+        srcTree.setProperty("foo", "x");
+
+        srcTree.addChild("a").setOrderableChildren(true);
+        srcTree.addChild("a").setProperty("foo", "y");
+
+        srcTree.addChild("b").setOrderableChildren(true);
+        srcTree.addChild("b").setProperty("foo", "z");
+
+        Tree tree = TreeFactory.createTree(EMPTY_NODE.builder());
+        NodeStateCopyUtils.copyToTree(testBuilder.getNodeState(), tree);
+
+        assertEquals("x", tree.getProperty("foo").getValue(Type.STRING));
+        assertEquals(2, tree.getChildrenCount(100));
+        assertEquals("y", 
tree.getChild("a").getProperty("foo").getValue(Type.STRING));
+        assertEquals("z", 
tree.getChild("b").getProperty("foo").getValue(Type.STRING));
+
+        //Assert the order
+        Iterator<Tree> children = tree.getChildren().iterator();
+        assertEquals("a", children.next().getName());
+        assertEquals("b", children.next().getName());
+    }
+
+    @Test
+    public void copyToJcr() throws Exception{
+        repository = new Jcr().with(new 
OpenSecurityProvider()).createRepository();
+
+        Tree srcTree = TreeFactory.createTree(builder);
+        srcTree.setOrderableChildren(true);
+        srcTree.setProperty("foo", "x");
+        srcTree.setProperty("foo", "x");
+        srcTree.setProperty(JcrConstants.JCR_PRIMARYTYPE, NT_OAK_UNSTRUCTURED, 
Type.NAME);
+
+        srcTree.addChild("a").setOrderableChildren(true);
+        srcTree.addChild("a").setProperty("foo", "y");
+        srcTree.addChild("a").setProperty(JcrConstants.JCR_PRIMARYTYPE, 
NT_OAK_UNSTRUCTURED, Type.NAME);
+
+        srcTree.addChild("b").setOrderableChildren(true);
+        srcTree.addChild("b").setProperty("foo", "z");
+        srcTree.addChild("b").setProperty(JcrConstants.JCR_PRIMARYTYPE, 
NT_OAK_UNSTRUCTURED, Type.NAME);
+
+        Session session = repository.login(null, null);
+        Node node = session.getRootNode();
+        Node test = node.addNode("test", NT_OAK_UNSTRUCTURED);
+
+        NodeStateCopyUtils.copyToNode(builder.getNodeState(), test);
+        session.save();
+
+        test = session.getNode("/test");
+        assertEquals("y", test.getProperty("a/foo").getString());
+        assertEquals("z", test.getProperty("b/foo").getString());
+    }
+
+    @Test
+    public void copyToJcrAndHiddenProps() throws Exception{
+        repository = new Jcr().with(new 
OpenSecurityProvider()).createRepository();
+
+        Tree srcTree = TreeFactory.createTree(builder);
+        srcTree.addChild("a").setProperty("foo", "y");
+        srcTree.addChild("a").setProperty(JcrConstants.JCR_PRIMARYTYPE, 
NT_OAK_UNSTRUCTURED, Type.NAME);
+        builder.child(":hidden-node").setProperty("x", "y");
+        builder.setProperty(":hidden-prop", "y");
+
+        Session session = repository.login(null, null);
+        Node node = session.getRootNode();
+        Node test = node.addNode("test", NT_OAK_UNSTRUCTURED);
+
+        NodeStateCopyUtils.copyToNode(builder.getNodeState(), test);
+        session.save();
+
+        test = session.getNode("/test");
+        assertEquals("y", test.getProperty("a/foo").getString());
+    }
+
+    @Test
+    public void copyToJcrVariousProps() throws Exception{
+        repository = new Jcr().with(new 
OpenSecurityProvider()).createRepository();
+
+        Calendar cal = ISO8601.parse(ISO8601.format(Calendar.getInstance()));
+        Tree srcTree = TreeFactory.createTree(builder);
+        srcTree.setOrderableChildren(true);
+        srcTree.setProperty("fooString", "x");
+        srcTree.setProperty("fooLong", 1L, Type.LONG);
+        srcTree.setProperty("fooPath", "/fooNode", Type.PATH);
+        srcTree.setProperty("fooName", "mix:title", Type.NAME);
+        srcTree.setProperty("fooDouble", 1.0, Type.DOUBLE);
+        srcTree.setProperty("fooDate", ISO8601.format(cal), Type.DATE);
+        srcTree.setProperty("fooBoolean", true, Type.BOOLEAN);
+        srcTree.setProperty("fooStrings", asList("a", "b"), Type.STRINGS);
+        srcTree.setProperty("fooBlob", new ArrayBasedBlob("foo".getBytes()), 
Type.BINARY);
+        srcTree.setProperty(JcrConstants.JCR_PRIMARYTYPE, NT_OAK_UNSTRUCTURED, 
Type.NAME);
+
+        srcTree.setProperty(JcrConstants.JCR_MIXINTYPES, 
asList("mix:mimeType", "mix:title"), Type.NAMES);
+
+        Session session = repository.login(null, null);
+        Node node = session.getRootNode();
+        Node test = node.addNode("test", NT_OAK_UNSTRUCTURED);
+        Node fooNode = node.addNode("fooNode", NT_OAK_UNSTRUCTURED);
+
+        NodeStateCopyUtils.copyToNode(builder.getNodeState(), test);
+        session.save();
+
+        test = session.getNode("/test");
+        assertEquals("x", test.getProperty("fooString").getString());
+        assertEquals("/fooNode", 
test.getProperty("fooPath").getNode().getPath());
+        assertEquals("mix:title", test.getProperty("fooName").getString());
+        assertEquals(1, test.getProperty("fooLong").getLong());
+
+        assertEquals(cal, test.getProperty("fooDate").getDate());
+        assertEquals("a", 
test.getProperty("fooStrings").getValues()[0].getString());
+        assertEquals("b", 
test.getProperty("fooStrings").getValues()[1].getString());
+
+        InputStream is = test.getProperty("fooBlob").getBinary().getStream();
+        String streamVal = IOUtils.toString(is, "UTF-8");
+        assertEquals("foo", streamVal);
+    }
+
+}
\ No newline at end of file

Propchange: 
jackrabbit/oak/trunk/oak-search/src/test/java/org/apache/jackrabbit/oak/plugins/index/search/util/NodeStateCopyUtilsTest.java
------------------------------------------------------------------------------
    svn:eol-style = native


Reply via email to