Author: mduerig
Date: Mon Mar 17 10:33:25 2014
New Revision: 1578291
URL: http://svn.apache.org/r1578291
Log:
OAK-650: Move SegmentNodeStoreBranch.RebaseDiff to utility package
Test cases
Added:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/state/AbstractRebaseDiffTest.java
Added:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/state/AbstractRebaseDiffTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/state/AbstractRebaseDiffTest.java?rev=1578291&view=auto
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/state/AbstractRebaseDiffTest.java
(added)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/state/AbstractRebaseDiffTest.java
Mon Mar 17 10:33:25 2014
@@ -0,0 +1,305 @@
+/*
+ * 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.spi.state;
+
+import static
org.apache.jackrabbit.oak.plugins.memory.PropertyStates.createProperty;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.jackrabbit.oak.api.PropertyState;
+import org.apache.jackrabbit.oak.plugins.memory.EmptyNodeState;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AbstractRebaseDiffTest {
+ private final NodeState base; {
+ NodeBuilder builder = EmptyNodeState.EMPTY_NODE.builder();
+ builder.setChildNode("a");
+ builder.setChildNode("b");
+ builder.setChildNode("c");
+ builder.setProperty("x", 1);
+ builder.setProperty("y", 1);
+ builder.setProperty("z", 1);
+ base = builder.getNodeState();
+ }
+
+ @Test
+ public void addExistingProperty() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.setProperty("p", 1);
+ headBuilder.setProperty("p", 1);
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.setProperty("p", 1);
+ branchBuilder.setProperty("p", 0);
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void addExistingProperty(NodeBuilder builder,
PropertyState before, PropertyState after) {
+ assertEquals(createProperty("p", 0), after);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void changeDeletedProperty() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.removeProperty("x");
+ headBuilder.removeProperty("y");
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.setProperty("x", 1);
+ branchBuilder.setProperty("y", 0);
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void changeDeletedProperty(NodeBuilder builder,
PropertyState after) {
+ assertEquals(createProperty("y", 0), after);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void changeChangedProperty() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.setProperty("x", 11);
+ headBuilder.setProperty("y", 22);
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.setProperty("x", 11);
+ branchBuilder.setProperty("y", 0);
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void changeChangedProperty(NodeBuilder builder,
PropertyState before, PropertyState after) {
+ assertEquals(createProperty("y", 0), after);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void deleteDeletedProperty() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.removeProperty("x");
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.removeProperty("x");
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void deleteDeletedProperty(NodeBuilder builder,
PropertyState before) {
+ assertEquals(createProperty("x", 1), before);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void deleteChangedProperty() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.setProperty("x", 11);
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.removeProperty("x");
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void deleteChangedProperty(NodeBuilder builder,
PropertyState before) {
+ assertEquals(createProperty("x", 1), before);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void addExistingNode() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.setChildNode("m");
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.setChildNode("m").setChildNode("mm");
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void addExistingNode(NodeBuilder builder, String name,
NodeState before, NodeState after) {
+ assertEquals("m", name);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void changeDeletedNode() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.getChildNode("a").remove();
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.getChildNode("a").setChildNode("aa");
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void changeDeletedNode(NodeBuilder builder, String name,
NodeState after) {
+ assertEquals("a", name);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void deleteDeletedNode() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.getChildNode("a").remove();
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.getChildNode("a").remove();
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void deleteDeletedNode(NodeBuilder builder, String name,
NodeState before) {
+ assertEquals("a", name);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ @Test
+ public void deleteChangedNode() {
+ NodeBuilder headBuilder = base.builder();
+ headBuilder.getChildNode("a").setChildNode("aa");
+ NodeState head = headBuilder.getNodeState();
+
+ NodeBuilder branchBuilder = base.builder();
+ branchBuilder.getChildNode("a").remove();
+ NodeState branch = branchBuilder.getNodeState();
+
+ RebaseDiff rebaseDiff = new RebaseDiff(head.builder()) {
+ @Override
+ protected void deleteChangedNode(NodeBuilder builder, String name,
NodeState before) {
+ assertEquals("a", name);
+ resolve();
+ }
+ };
+ branch.compareAgainstBaseState(base, rebaseDiff);
+ assertTrue(rebaseDiff.isResolved());
+ }
+
+ //------------------------------------------------------------< RebaseDiff
>---
+
+ private static class RebaseDiff extends AbstractRebaseDiff {
+ private boolean resolved;
+
+ protected RebaseDiff(NodeBuilder builder) {
+ super(builder);
+ }
+
+ protected void resolve() {
+ resolved = true;
+ }
+
+ public boolean isResolved() {
+ return resolved;
+ }
+
+ @Override
+ protected AbstractRebaseDiff createDiff(NodeBuilder builder, String
name) {
+ return this;
+ }
+
+ @Override
+ protected void addExistingProperty(NodeBuilder builder, PropertyState
before, PropertyState after) {
+ Assert.fail("addExistingProperty " + after);
+ }
+
+ @Override
+ protected void changeDeletedProperty(NodeBuilder builder,
PropertyState after) {
+ Assert.fail("changeDeletedProperty " + after);
+ }
+
+ @Override
+ protected void changeChangedProperty(NodeBuilder builder,
PropertyState before, PropertyState after) {
+ Assert.fail("changeChangedProperty " + after);
+ }
+
+ @Override
+ protected void deleteDeletedProperty(NodeBuilder builder,
PropertyState before) {
+ Assert.fail("deleteDeletedProperty " + before);
+ }
+
+ @Override
+ protected void deleteChangedProperty(NodeBuilder builder,
PropertyState before) {
+ Assert.fail("deleteChangedProperty " + before);
+ }
+
+ @Override
+ protected void addExistingNode(NodeBuilder builder, String name,
NodeState before, NodeState after) {
+ Assert.fail("addExistingNode " + name + '=' + after);
+ }
+
+ @Override
+ protected void changeDeletedNode(NodeBuilder builder, String name,
NodeState after) {
+ Assert.fail("changeDeletedNode " + name + '=' + after);
+ }
+
+ @Override
+ protected void deleteDeletedNode(NodeBuilder builder, String name,
NodeState before) {
+ Assert.fail("deleteDeletedNode " + name + '=' + before);
+ }
+
+ @Override
+ protected void deleteChangedNode(NodeBuilder builder, String name,
NodeState before) {
+ Assert.fail("deleteChangedNode " + name + '=' + before);
+ }
+ }
+}
