You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jackrabbit.apache.org by md...@apache.org on 2012/02/13 13:45:51 UTC
svn commit: r1243491 - in /jackrabbit/sandbox/jackrabbit-microkernel/src:
main/java/org/apache/jackrabbit/state/ test/java/org/apache/jackrabbit/
test/java/org/apache/jackrabbit/state/
Author: mduerig
Date: Mon Feb 13 12:45:50 2012
New Revision: 1243491
URL: http://svn.apache.org/viewvc?rev=1243491&view=rev
Log:
Microkernel based prototype of JCR implementation (WIP)
- Minor refactorings/clean up
Modified:
jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java
jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java
jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java
jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java
jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java
Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java Mon Feb 13 12:45:50 2012
@@ -160,7 +160,7 @@ public class NodeState {
}
public static NodeState getNodeState(Context sessionContext, Path path) {
- NodeDelta delta = sessionContext.getTransientSpace().getNode(path);
+ NodeDelta delta = sessionContext.getTransientSpace().getNodeDelta(path);
return delta == null ? null : getNodeState(sessionContext, delta);
}
Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java Mon Feb 13 12:45:50 2012
@@ -87,11 +87,11 @@ public class TransientSpace {
/**
* @param path
- * @return the node at the given {@code path}. The node is either a persisted node in the
+ * @return the node delta for the given {@code path}. This is either a persisted node in the
* revision currently bound to this transient space or a transient node or {@code null}
- * if no such node exists.
+ * if no such node delta exists.
*/
- public NodeDelta getNode(Path path) {
+ public NodeDelta getNodeDelta(Path path) {
return changeTree.getNode(path);
}
@@ -121,6 +121,7 @@ public class TransientSpace {
*/
public String refresh(boolean keepChanges) {
if (!keepChanges) {
+ changeLog.clear();
changeTree.clear();
}
Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java Mon Feb 13 12:45:50 2012
@@ -81,7 +81,7 @@ import static org.junit.Assert.fail;
public class RepositoryTest {
private static final String NODE_STATE_CACHE_SIZE = "65536";
- private static final String URL = "fs:target/repository-test/repository";
+ private static final String URL = "fs:target/repository-test/repository;clean";
// private static final String URL = "mem:";
private static final String TEST_NODE = "test_node";
Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java Mon Feb 13 12:45:50 2012
@@ -161,7 +161,7 @@ public class TransientSpaceFuzzTest {
@Override
void apply(TransientSpace transientSpace) throws ItemExistsException {
- transientSpace.getNode(parent).addNode(name);
+ transientSpace.getNodeDelta(parent).addNode(name);
}
@Override
@@ -184,7 +184,7 @@ public class TransientSpaceFuzzTest {
@Override
void apply(TransientSpace transientSpace) throws ItemNotFoundException {
- transientSpace.getNode(path.getParent()).removeNode(path.getName());
+ transientSpace.getNodeDelta(path.getParent()).removeNode(path.getName());
}
@Override
@@ -210,7 +210,7 @@ public class TransientSpaceFuzzTest {
@Override
void apply(TransientSpace transientSpace) throws RepositoryException {
- transientSpace.getNode(source.getParent()).moveNode(source.getName(), destination);
+ transientSpace.getNodeDelta(source.getParent()).moveNode(source.getName(), destination);
}
@Override
@@ -238,7 +238,7 @@ public class TransientSpaceFuzzTest {
@Override
void apply(TransientSpace transientSpace) throws RepositoryException {
- transientSpace.getNode(parent).setValue(name, value);
+ transientSpace.getNodeDelta(parent).setValue(name, value);
}
@Override
Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java Mon Feb 13 12:45:50 2012
@@ -55,87 +55,87 @@ public class TransientSpaceTest {
@Test
public void getNotExistingNode() {
- assertNull(transientSpace.getNode(ROOT.concat("any")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("any")));
}
@Test
public void addNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("added");
Path addedPath = ROOT.concat("added");
- NodeDelta added = transientSpace.getNode(addedPath);
+ NodeDelta added = transientSpace.getNodeDelta(addedPath);
assertEquals(addedPath, added.getPath());
transientSpace.save();
- added = transientSpace.getNode(addedPath);
+ added = transientSpace.getNodeDelta(addedPath);
assertEquals(addedPath, added.getPath());
}
@Test
public void addNodes() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b").addNode("c");
transientSpace.save();
- NodeDelta c = transientSpace.getNode(ROOT.concat("a/b/c"));
+ NodeDelta c = transientSpace.getNodeDelta(ROOT.concat("a/b/c"));
c.addNode("d").addNode("e");
c.addNode("f");
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/d/e")));
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/f")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/d/e")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/f")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/d/e")));
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/f")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/d/e")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/f")));
}
@Test(expected = ItemNotFoundException.class)
public void removeNotExistingNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.removeNode("remove");
transientSpace.save();
}
@Test
public void removeExistingNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("added");
transientSpace.save();
Path addedPath = ROOT.concat("added");
- assertNotNull(transientSpace.getNode(addedPath));
+ assertNotNull(transientSpace.getNodeDelta(addedPath));
- root = transientSpace.getNode(ROOT);
+ root = transientSpace.getNodeDelta(ROOT);
root.removeNode("added");
- assertNull(transientSpace.getNode(addedPath));
+ assertNull(transientSpace.getNodeDelta(addedPath));
transientSpace.save();
- assertNull(transientSpace.getNode(addedPath));
+ assertNull(transientSpace.getNodeDelta(addedPath));
}
@Test
public void removeTransientNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("added");
Path addedPath = ROOT.concat("added");
- assertNotNull(transientSpace.getNode(addedPath));
+ assertNotNull(transientSpace.getNodeDelta(addedPath));
root.removeNode("added");
- assertNull(transientSpace.getNode(addedPath));
+ assertNull(transientSpace.getNodeDelta(addedPath));
transientSpace.save();
- assertNull(transientSpace.getNode(addedPath));
+ assertNull(transientSpace.getNodeDelta(addedPath));
}
@Test(expected = ItemNotFoundException.class)
public void removeRemovedNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("added");
transientSpace.save();
Path addedPath = ROOT.concat("added");
- NodeDelta added = transientSpace.getNode(addedPath);
+ NodeDelta added = transientSpace.getNodeDelta(addedPath);
added.addNode("added2");
assertTrue(added.hasNode("added2"));
@@ -146,7 +146,7 @@ public class TransientSpaceTest {
@Test
public void removeAndAddAgain() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b");
transientSpace.save();
@@ -171,7 +171,7 @@ public class TransientSpaceTest {
@Test
public void moveAndAddAgain() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b");
transientSpace.save();
@@ -196,7 +196,7 @@ public class TransientSpaceTest {
@Test
public void removeAfterMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b");
root.addNode("x");
transientSpace.save();
@@ -205,309 +205,309 @@ public class TransientSpaceTest {
root.removeNode("a");
assertNull(root.getNode("a"));
- assertNotNull(transientSpace.getNode(ROOT.concat("x/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("x/bm")));
transientSpace.save();
assertNull(root.getNode("a"));
- assertNotNull(transientSpace.getNode(ROOT.concat("x/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("x/bm")));
}
@Test
public void moveTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveExisting() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test(expected = ItemNotFoundException.class)
public void moveNotExistingSource() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
}
@Test(expected = PathNotFoundException.class)
public void moveToNotExistingTarget() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
}
@Test(expected = ItemExistsException.class)
public void moveToExistingTarget() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target").addNode("moved");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
}
@Test
public void rename() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("source/moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/moved")));
}
@Test
public void moveSubTree() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
NodeDelta b = root.addNode("a").addNode("b");
b.addNode("c").addNode("d");
NodeDelta w = root.addNode("v").addNode("w");
w.addNode("x").addNode("y");
transientSpace.save();
- b = transientSpace.getNode(ROOT.concat("a/b"));
+ b = transientSpace.getNodeDelta(ROOT.concat("a/b"));
b.moveNode("c", w.getPath().concat("c-moved"));
- assertNull(transientSpace.getNode(ROOT.concat("a/b/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b")));
- assertNotNull(transientSpace.getNode(ROOT.concat("v/w/x/y")));
- assertNotNull(transientSpace.getNode(ROOT.concat("v/w/c-moved/d")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/x/y")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/c-moved/d")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("a/b/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("a/b")));
- assertNotNull(transientSpace.getNode(ROOT.concat("v/w/x/y")));
- assertNotNull(transientSpace.getNode(ROOT.concat("v/w/c-moved/d")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/x/y")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/c-moved/d")));
}
@Test
public void modifyThenMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node").addNode("c");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
NodeDelta moveNode = sourceNode.getNode("node");
moveNode.addNode("a").addNode("b");
moveNode.removeNode("c");
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
}
@Test
public void moveThenModify() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node").addNode("c");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- NodeDelta movedNode = transientSpace.getNode(ROOT.concat("target/moved"));
+ NodeDelta movedNode = transientSpace.getNodeDelta(ROOT.concat("target/moved"));
movedNode.addNode("a").addNode("b");
movedNode.removeNode("c");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
}
@Test
public void modifyThenMoveThenModify() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node").addNode("c1");
root.getNode("source").getNode("node").addNode("c2");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
NodeDelta moveNode = sourceNode.getNode("node");
moveNode.addNode("a1").addNode("b1");
moveNode.removeNode("c1");
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- NodeDelta movedNode = transientSpace.getNode(ROOT.concat("target/moved"));
+ NodeDelta movedNode = transientSpace.getNodeDelta(ROOT.concat("target/moved"));
movedNode.addNode("a2").addNode("b2");
movedNode.removeNode("c2");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a1/b1")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a2/b2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a1/b1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a2/b2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a1/b1")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved/c2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a2/b2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a1/b1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a2/b2")));
}
@Test
public void moveThenDelete() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
root.getNode("target").removeNode("moved");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveFromAddedThenDelete() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source");
root.addNode("target");
transientSpace.save();
root.getNode("source").addNode("node");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
root.getNode("target").removeNode("moved");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveToAddedThenDelete() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
transientSpace.save();
root.addNode("target");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
root.getNode("target").removeNode("moved");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveFromAddedToAddedThenDelete() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source");
transientSpace.save();
root.getNode("source").addNode("node");
root.addNode("target");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
root.getNode("target").removeNode("moved");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveMoved() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
@@ -518,23 +518,23 @@ public class TransientSpaceTest {
NodeDelta target1 = root.getNode("target1");
target1.moveNode("moved1", ROOT.concat("target2/moved2"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
}
@Test
public void moveMovedIndirect() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
@@ -546,147 +546,147 @@ public class TransientSpaceTest {
sourceNode.moveNode("node", ROOT.concat("target1/child/node-moved"));
target1.moveNode("child", ROOT.concat("target2/child-moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/child-moved/node-moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/child-moved/node-moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/child-moved/node-moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/child-moved/node-moved")));
}
@Test
public void moveMovedThenDelete() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target1/moved1"));
NodeDelta target1 = root.getNode("target1");
target1.moveNode("moved1", ROOT.concat("target2/moved2"));
root.getNode("target2").removeNode("moved2");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
}
@Test
public void moveMovedThenDeleteTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source");
transientSpace.save();
root.getNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target1/moved1"));
NodeDelta target1 = root.getNode("target1");
target1.moveNode("moved1", ROOT.concat("target2/moved2"));
root.getNode("target2").removeNode("moved2");
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
}
@Test
public void moveForthAndBack() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
transientSpace.save();
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
NodeDelta target = root.getNode("target");
target.moveNode("moved", ROOT.concat("source/node"));
- assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveForthAndBackTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source");
root.getNode("source").addNode("node");
transientSpace.save();
root.addNode("target");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
NodeDelta target = root.getNode("target");
target.moveNode("moved", ROOT.concat("source/node"));
- assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveFromTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("target");
transientSpace.save();
root.addNode("source1").addNode("node");
- NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source1"));
+ NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source1"));
sourceNode.moveNode("node", ROOT.concat("target/moved"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveIntoMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node1").addNode("child");
root.getNode("source").addNode("node2");
root.addNode("target");
@@ -695,20 +695,20 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node1", ROOT.concat("target/moved1"));
root.getNode("source").moveNode("node2", ROOT.concat("target/moved1/child/moved2"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
}
@Test
public void moveIntoMoveTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node1").addNode("child");
root.getNode("source").addNode("node2");
root.addNode("target");
@@ -716,20 +716,20 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node1", ROOT.concat("target/moved1"));
root.getNode("source").moveNode("node2", ROOT.concat("target/moved1/child/moved2"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
}
@Test
public void moveOutOfMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node1").addNode("child");
root.addNode("target1");
root.addNode("target2");
@@ -738,22 +738,22 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node1", ROOT.concat("target1/moved1"));
root.getNode("target1").getNode("moved1").moveNode("child", ROOT.concat("target2/moved2"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
}
@Test
public void moveMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b");
root.addNode("t1");
transientSpace.save();
@@ -761,22 +761,22 @@ public class TransientSpaceTest {
root.moveNode("a", ROOT.concat("t1/am"));
root.getNode("t1").getNode("am").moveNode("b", ROOT.concat("bm"));
- assertNull(transientSpace.getNode(ROOT.concat("a")));
- assertNotNull(transientSpace.getNode(ROOT.concat("t1/am")));
- assertNull(transientSpace.getNode(ROOT.concat("t1/am/b")));
- assertNotNull(transientSpace.getNode(ROOT.concat("bm")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("a")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("t1/am")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("t1/am/b")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("a")));
- assertNotNull(transientSpace.getNode(ROOT.concat("t1/am")));
- assertNull(transientSpace.getNode(ROOT.concat("t1/am/b")));
- assertNotNull(transientSpace.getNode(ROOT.concat("bm")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("a")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("t1/am")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("t1/am/b")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm")));
}
@Test
public void moveOutOfMoveTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node1").addNode("child");
root.addNode("target1");
root.addNode("target2");
@@ -784,22 +784,22 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node1", ROOT.concat("target1/moved1"));
root.getNode("target1").getNode("moved1").moveNode("child", ROOT.concat("target2/moved2"));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
- assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
}
@Test
public void moveMovedParent() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
@@ -808,22 +808,22 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node", ROOT.concat("target1/moved"));
root.moveNode("target1", ROOT.concat("target2/moved-target1"));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
}
@Test
public void moveMovedParentTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target1");
root.addNode("target2");
@@ -831,21 +831,21 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node", ROOT.concat("target1/moved"));
root.moveNode("target1", ROOT.concat("target2/moved-target1"));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target1")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target1")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
}
@Test
public void removeMoved() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
transientSpace.save();
@@ -853,40 +853,40 @@ public class TransientSpaceTest {
root.getNode("source").moveNode("node", ROOT.concat("target/moved"));
root.removeNode("target");
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
}
@Test
public void removeMovedTransient() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node");
root.addNode("target");
root.getNode("source").moveNode("node", ROOT.concat("target/moved"));
root.removeNode("target");
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node")));
- assertNull(transientSpace.getNode(ROOT.concat("target")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
}
@Test
public void moveAddedToMove() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("source").addNode("node1");
transientSpace.save();
@@ -894,40 +894,40 @@ public class TransientSpaceTest {
root.getNode("source").addNode("node2");
root.getNode("source").moveNode("node2", ROOT.concat("target/moved"));
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
transientSpace.save();
- assertNotNull(transientSpace.getNode(ROOT.concat("source")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
- assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
}
@Test
public void moveToAdded() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("node");
transientSpace.save();
root.addNode("target");
root.moveNode("node", ROOT.concat("target/node-moved"));
- assertNull(transientSpace.getNode(ROOT.concat("node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/node-moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/node-moved")));
transientSpace.save();
- assertNull(transientSpace.getNode(ROOT.concat("node")));
- assertNotNull(transientSpace.getNode(ROOT.concat("target/node-moved")));
+ assertNull(transientSpace.getNodeDelta(ROOT.concat("node")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/node-moved")));
}
@Test
public void moveIntoSameBranch() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a");
root.addNode("b");
transientSpace.save();
@@ -937,18 +937,18 @@ public class TransientSpaceTest {
assertNull(root.getNode("a"));
assertNull(root.getNode("b"));
- assertNotNull(transientSpace.getNode(ROOT.concat("am/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/bm")));
transientSpace.save();
assertNull(root.getNode("a"));
assertNull(root.getNode("b"));
- assertNotNull(transientSpace.getNode(ROOT.concat("am/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/bm")));
}
@Test
public void moveIntoSameBranchIndirect() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a");
root.addNode("b");
transientSpace.save();
@@ -959,18 +959,18 @@ public class TransientSpaceTest {
assertNull(root.getNode("a"));
assertNull(root.getNode("b"));
- assertNotNull(transientSpace.getNode(ROOT.concat("am/c/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/c/bm")));
transientSpace.save();
assertNull(root.getNode("a"));
assertNull(root.getNode("b"));
- assertNotNull(transientSpace.getNode(ROOT.concat("am/c/bm")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/c/bm")));
}
@Test
public void moveToReverse() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("a").addNode("b");
transientSpace.save();
@@ -978,18 +978,18 @@ public class TransientSpaceTest {
root.moveNode("a", ROOT.concat("bm/am"));
assertNull(root.getNode("a"));
- assertNotNull(transientSpace.getNode(ROOT.concat("bm/am")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm/am")));
transientSpace.save();
assertNull(root.getNode("a"));
- assertNotNull(transientSpace.getNode(ROOT.concat("bm/am")));
+ assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm/am")));
}
@Test
public void setPropertyTest() throws RepositoryException {
// Set property
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.setValue("prop", JsonAtom.number(42));
transientSpace.save();
assertThat(mk, propertyHasValue(ROOT.concat("prop"), 42));
@@ -1029,7 +1029,7 @@ public class TransientSpaceTest {
@Test
public void liveNode() throws RepositoryException {
- NodeDelta root = transientSpace.getNode(ROOT);
+ NodeDelta root = transientSpace.getNodeDelta(ROOT);
root.addNode("test");
transientSpace.save();