jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ju...@apache.org
Subject svn commit: r792142 [25/35] - in /jackrabbit/sandbox/JCR-1456: ./ jackrabbit-api/src/main/java/org/apache/jackrabbit/api/ jackrabbit-api/src/main/java/org/apache/jackrabbit/api/security/ jackrabbit-core/ jackrabbit-core/src/main/java/org/apache/jackrab...
Date Wed, 08 Jul 2009 13:57:46 GMT
Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RestoreTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RestoreTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RestoreTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/RestoreTest.java Wed Jul  8 13:57:13 2009
@@ -19,7 +19,11 @@
 import org.apache.jackrabbit.test.NotExecutableException;
 
 import javax.jcr.nodetype.NodeDefinition;
-import javax.jcr.version.*;
+import javax.jcr.version.OnParentVersionAction;
+import javax.jcr.version.Version;
+import javax.jcr.version.VersionException;
+import javax.jcr.version.VersionIterator;
+import javax.jcr.version.VersionManager;
 import javax.jcr.Node;
 import javax.jcr.RepositoryException;
 import javax.jcr.InvalidItemStateException;
@@ -939,12 +943,11 @@
      * Test the restore of the OPV=Version child nodes.
      * @throws RepositoryException
      */
-    public void testRestoreName() throws RepositoryException {
+    public void testRestoreName() throws RepositoryException,
+            NotExecutableException {
         // V1.0 of versionableNode has no child
         Node child1 = versionableNode.addNode(nodeName4);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         versionableNode.getSession().save();
         // create v1.0 of child
         Version v1Child = child1.checkin();
@@ -980,12 +983,11 @@
      * Test the restore of the OPV=Version child nodes.
      * @throws RepositoryException
      */
-    public void testRestoreNameJcr2() throws RepositoryException {
+    public void testRestoreNameJcr2() throws RepositoryException,
+            NotExecutableException {
         // V1.0 of versionableNode has no child
         Node child1 = versionableNode.addNode(nodeName4);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         versionableNode.getSession().save();
         // create v1.0 of child
         Version v1Child = child1.checkin();
@@ -1021,21 +1023,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder() throws RepositoryException {
+    public void testRestoreOrder() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         child1.checkin();
         child2.checkin();
@@ -1065,21 +1064,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrderJcr2() throws RepositoryException {
+    public void testRestoreOrderJcr2() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1109,21 +1105,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrderJcr2_2() throws RepositoryException {
+    public void testRestoreOrderJcr2_2() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1153,21 +1146,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrderJcr2_3() throws RepositoryException {
+    public void testRestoreOrderJcr2_3() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1197,21 +1187,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrderJcr2_4() throws RepositoryException {
+    public void testRestoreOrderJcr2_4() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1241,21 +1228,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder2() throws RepositoryException {
+    public void testRestoreOrder2() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         child1.checkin();
         child2.checkin();
@@ -1285,21 +1269,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder2Jcr2() throws RepositoryException {
+    public void testRestoreOrder2Jcr2() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1329,21 +1310,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder2Jcr2_2() throws RepositoryException {
+    public void testRestoreOrder2Jcr2_2() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1373,21 +1351,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder2Jcr2_3() throws RepositoryException {
+    public void testRestoreOrder2Jcr2_3() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());
@@ -1417,21 +1392,18 @@
      * Test the child ordering of restored nodes.
      * @throws RepositoryException
      */
-    public void testRestoreOrder2Jcr2_4() throws RepositoryException {
+    public void testRestoreOrder2Jcr2_4() throws RepositoryException,
+            NotExecutableException {
         // create a test-root that has orderable child nodes
         Node testRoot = versionableNode.addNode(nodeName4, "nt:unstructured");
-        testRoot.addMixin(mixVersionable);
+        ensureMixinType(testRoot, mixVersionable);
         versionableNode.getSession().save();
 
         // create children of vNode and checkin
         Node child1 = testRoot.addNode(nodeName1);
-        if (!child1.isNodeType(mixVersionable)) {
-            child1.addMixin(mixVersionable);
-        }
+        ensureMixinType(child1, mixVersionable);
         Node child2 = testRoot.addNode(nodeName2);
-        if (!child2.isNodeType(mixVersionable)) {
-            child2.addMixin(mixVersionable);
-        }
+        ensureMixinType(child2, mixVersionable);
         testRoot.getSession().save();
         versionManager.checkin(child1.getPath());
         versionManager.checkin(child2.getPath());

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/TestAll.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/TestAll.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/TestAll.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/TestAll.java Wed Jul  8 13:57:13 2009
@@ -42,6 +42,7 @@
         suite.addTestSuite(VersionLabelTest.class);
         suite.addTestSuite(CheckoutTest.class);
         suite.addTestSuite(CheckinTest.class);
+        suite.addTestSuite(CopyTest.class);
         suite.addTestSuite(VersionGraphTest.class);
         suite.addTestSuite(RemoveVersionTest.class);
         suite.addTestSuite(RestoreTest.class);
@@ -65,6 +66,10 @@
         suite.addTestSuite(MergeNodeTest.class);
         suite.addTestSuite(MergeNonVersionableSubNodeTest.class);
         suite.addTestSuite(MergeSubNodeTest.class);
+        
+        // JCR 2.0
+
+        suite.addTestSuite(ActivitiesTest.class);
 
         return suite;
     }

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionGraphTest.java Wed Jul  8 13:57:13 2009
@@ -17,6 +17,7 @@
 package org.apache.jackrabbit.test.api.version;
 
 import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
 import javax.jcr.RepositoryException;
 import javax.jcr.Property;
 import javax.jcr.Value;
@@ -48,6 +49,22 @@
     }
 
     /**
+     * Test that the initial base version after creation of a versionable node
+     * points to the root version.
+     *
+     * @throws javax.jcr.RepositoryException
+     */
+    public void testInitialBaseVersionPointsToRootVersionJcr2() throws RepositoryException {
+
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        Version rV = versionManager.getVersionHistory(path).getRootVersion();
+        Version bV = versionManager.getBaseVersion(path);
+
+        assertTrue("After creation of a versionable node the node's baseVersion must point to the rootVersion in the version history.", rV.isSame(bV));
+    }
+
+    /**
      * Test if after creation of a versionable node N the multi-value
      * REFERENCE property jcr:predecessors of N is initialized to contain a
      * single UUID, that of the root version (the same as jcr:baseVersion).
@@ -69,6 +86,27 @@
     }
 
     /**
+     * Test if after creation of a versionable node N the multi-value
+     * REFERENCE property jcr:predecessors of N is initialized to contain a
+     * single UUID, that of the root version (the same as jcr:baseVersion).
+     *
+     * @throws RepositoryException
+     */
+    public void testInitialNodePredecessorsJcr2() throws RepositoryException {
+
+        Property predecessors = versionableNode.getProperty(jcrPredecessors);
+        Value[] values = predecessors.getValues();
+        Version rV = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion();
+        if (values.length != 1) {
+            fail("The jcr:predecessors property of a versionable node must be initialized to contain a single value");
+        }
+
+        Value initialVal = values[0];
+
+        assertTrue("The jcr:predecessors property of a versionable node is initialized to contain a single UUID, that of the root version", initialVal.equals(superuser.getValueFactory().createValue(rV)));
+    }
+
+    /**
      * Test if the root version does not have any predecessor versions.
      *
      * @throws RepositoryException
@@ -79,6 +117,16 @@
     }
 
     /**
+     * Test if the root version does not have any predecessor versions.
+     *
+     * @throws RepositoryException
+     */
+    public void testRootVersionHasNoPredecessorJcr2() throws RepositoryException {
+        Version[] predec = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath()).getRootVersion().getPredecessors();
+        assertTrue("The root version may not have any predecessors.", predec.length == 0);
+    }
+
+    /**
      * Test if UnsupportedRepositoryOperationException is thrown when calling
      * Node.getVersionHistory() on a non-versionable node.
      *
@@ -92,4 +140,19 @@
             //success
         }
     }
+
+    /**
+     * Test if UnsupportedRepositoryOperationException is thrown when calling
+     * Node.getVersionHistory() on a non-versionable node.
+     *
+     * @throws RepositoryException
+     */
+    public void testGetBaseVersionOnNonVersionableNodeJcr2() throws RepositoryException {
+        try {
+            nonVersionableNode.getSession().getWorkspace().getVersionManager().getBaseVersion(nonVersionableNode.getPath());
+            fail("Node.getBaseVersion() must throw UnsupportedRepositoryOperationException if the node is not versionable.");
+        } catch (UnsupportedRepositoryOperationException e) {
+            //success
+        }
+    }
 }
\ No newline at end of file

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionHistoryTest.java Wed Jul  8 13:57:13 2009
@@ -37,6 +37,7 @@
 import javax.jcr.UnsupportedRepositoryOperationException;
 import javax.jcr.Value;
 import javax.jcr.lock.LockException;
+import javax.jcr.lock.LockManager;
 import javax.jcr.nodetype.ConstraintViolationException;
 import javax.jcr.nodetype.NoSuchNodeTypeException;
 import javax.jcr.nodetype.NodeType;
@@ -59,6 +60,7 @@
 
     protected VersionHistory vHistory;
     private Version version;
+    private VersionManager versionManager;
 
     /**
      * helper class used in testAccept()
@@ -82,9 +84,10 @@
     protected void setUp() throws Exception {
         super.setUp();
 
-        version = versionableNode.checkin();
+        versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        version = versionManager.checkin(versionableNode.getPath());
 
-        vHistory = versionableNode.getVersionHistory();
+        vHistory = versionManager.getVersionHistory(versionableNode.getPath());
 
 
         if (vHistory == null) {
@@ -206,6 +209,35 @@
     }
 
     /**
+     * Test that {@link VersionHistory#getAllVersions()} returns an iterator
+     * containing the root version and all versions that have been created by
+     * Node.checkin().
+     *
+     * @see javax.jcr.version.VersionHistory#getAllVersions()
+     */
+    public void testGetAllVersionsJcr2() throws RepositoryException {
+        int cnt = 5;
+        HashMap versions = new HashMap();
+        Version v = vHistory.getRootVersion();
+        versions.put(v.getIdentifier(), v);
+        for (int i = 0; i < cnt; i++) {
+            v = versionManager.checkin(versionableNode.getPath());
+            versions.put(v.getIdentifier(), v);
+            versionManager.checkout(versionableNode.getPath());
+        }
+
+        VersionIterator it = vHistory.getAllVersions();
+        while (it.hasNext()) {
+            v = it.nextVersion();
+            if (!versions.containsKey(v.getIdentifier())) {
+                fail("VersionHistory.getAllVersions() must only contain the root version and versions, that have been created by a Node.checkin() call.");
+            }
+            versions.remove(v.getIdentifier());
+        }
+        assertTrue("VersionHistory.getAllVersions() must contain the root version and all versions that have been created with a Node.checkin() call.", versions.isEmpty());
+    }
+
+    /**
      * Test that {@link VersionHistory#getAllFrozenNodes()} returns an iterator
      * containing the frozen nodes of all versions that have been created by
      * {@link VersionManager#checkpoint(String)}.
@@ -255,6 +287,19 @@
     }
 
     /**
+     * Test if UnsupportedRepositoryOperationException is thrown when calling
+     * Node.getVersionHistory() on a non-versionable node.
+     */
+    public void testGetVersionHistoryOnNonVersionableNodeJcr2() throws RepositoryException {
+        try {
+            versionManager.getVersionHistory(nonVersionableNode.getPath());
+            fail("Node.getVersionHistory() must throw UnsupportedRepositoryOperationException if the node is not versionable.");
+        } catch (UnsupportedRepositoryOperationException e) {
+            //success
+        }
+    }
+
+    /**
      * Test VersionHistory.getVersion(String versionName) if 'versionName' is
      * the name of an existing version (created by Node.checkin()).
      *
@@ -262,7 +307,7 @@
      */
     public void testGetVersion() throws RepositoryException {
 
-        Version v = versionableNode.checkin();
+        Version v = versionManager.checkin(versionableNode.getPath());
         Version v2 = vHistory.getVersion(v.getName());
 
         assertTrue("VersionHistory.getVersion(String versionName) must return the version that is identified by the versionName specified, if versionName is the name of a version created by Node.checkin().", v.isSame(v2));
@@ -284,7 +329,7 @@
     public void testAddMixin() throws Exception {
         try {
             vHistory.addMixin(mixVersionable);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.addMixin(String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -298,13 +343,13 @@
     public void testAddNode() throws Exception {
         try {
             vHistory.addNode(nodeName4);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.addNode(String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.addNode(nodeName4, ntBase);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.addNode(String,String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -331,6 +376,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.cancelMerge(Version)</code> throws an
+     * {@link javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCancelMergeJcr2() throws Exception {
+        try {
+            versionManager.cancelMerge(vHistory.getPath(), version);
+            fail("VersionHistory.cancelMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.checkin()</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -343,6 +400,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.checkin()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCheckinJcr2() throws Exception {
+        try {
+            versionManager.checkin(vHistory.getPath());
+            fail("VersionHistory.checkin() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.checkout()</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -355,6 +424,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.checkout()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCheckoutJcr2() throws Exception {
+        try {
+            versionManager.checkout(vHistory.getPath());
+            fail("VersionHistory.checkout() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.doneMerge(Version)</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -367,6 +448,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.doneMerge(Version)</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testDoneMergeJcr2() throws Exception {
+        try {
+            versionManager.doneMerge(vHistory.getPath(), version);
+            fail("VersionHistory should not be versionable: VersionHistory.doneMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.getAncestor(int)</code> returns the right
      * ancestor
      */
@@ -387,6 +480,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.getBaseVersion()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testGetBaseVersionJcr2() throws Exception {
+        try {
+            versionManager.getBaseVersion(vHistory.getPath());
+            fail("VersionHistory.getBaseVersion() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.getCorrespondingNodePath(String)</code>
      * returns the right path
      */
@@ -421,6 +526,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.getLock()</code> throws an {@link
+     * javax.jcr.lock.LockException}
+     */
+    public void testGetLockJcr2() throws Exception {
+        try {
+            vHistory.getSession().getWorkspace().getLockManager().getLock(vHistory.getPath());
+            fail("VersionHistory should not be lockable: VersionHistory.getLock() did not throw a LockException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.getMixinNodeTypes()</code> does not return
      * null.
      */
@@ -556,6 +673,13 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.getIdentifier()</code> returns the right UUID
+     */
+    public void testGetIdentifier() throws Exception {
+        assertEquals("VersionHistory.getIdentifier() did not return the right Id", versionableNode.getProperty(jcrVersionHistory).getString(), vHistory.getIdentifier());
+    }
+
+    /**
      * Tests if <code>VersionHistory.getVersionHistory()</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -568,6 +692,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.getVersionHistory()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testGetVersionHistoryJcr2() throws Exception {
+        try {
+            versionManager.getVersionHistory(vHistory.getPath());
+            fail("VersionHistory.getVersionHistory() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.hasNode(String)</code> returns the right
      * <code>boolean</code> value
      */
@@ -608,6 +744,14 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.holdsLock()</code> returns
+     * <code>false</code>
+     */
+    public void testHoldsLockJcr2() throws Exception {
+        assertFalse("VersionHistory.holdsLock() did not return false", vHistory.getSession().getWorkspace().getLockManager().holdsLock(vHistory.getPath()));
+    }
+
+    /**
      * Tests if <code>VersionHistory.isCheckedOut()</code> returns
      * <code>true</code>
      */
@@ -616,6 +760,14 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.isCheckedOut()</code> returns
+     * <code>true</code>
+     */
+    public void testIsCheckedOutJcr2() throws Exception {
+        assertTrue("VersionHistory.isCheckedOut() did not return true", versionManager.isCheckedOut(vHistory.getPath()));
+    }
+
+    /**
      * Tests if <code>VersionHistory.isLocked()</code> returns
      * <code>false</code>
      */
@@ -624,6 +776,14 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.isLocked()</code> returns
+     * <code>false</code>
+     */
+    public void testIsLockedJcr2() throws Exception {
+        assertFalse("VersionHistory.isLocked() did not return false", vHistory.getSession().getWorkspace().getLockManager().isLocked(vHistory.getPath()));
+    }
+
+    /**
      * Tests if <code>VersionHistory.isModified()</code> returns
      * <code>false</code>
      */
@@ -689,6 +849,35 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.lock(boolean, boolean)</code> throws a
+     * {@link javax.jcr.lock.LockException}
+     */
+    public void testLockJcr2() throws Exception {
+        LockManager lockManager = vHistory.getSession().getWorkspace().getLockManager();
+        String path = vHistory.getPath();
+        try {
+            lockManager.lock(path, true, true, 60, "");
+            fail("VersionHistory should not be lockable: VersionHistory.lock(true,true) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, true, false, 60, "");
+            fail("VersionHistory should not be lockable: VersionHistory.lock(true,false) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, false, true, 60, "");
+            fail("VersionHistory should not be lockable: VersionHistory.lock(false,true) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, false, false, 60, "");
+            fail("VersionHistory should not be lockable: VersionHistory.lock(false,false) did not throw a UnsupportedRepositoryOperationException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.merge(String)</code> throws an
      * {@link javax.jcr.nodetype.ConstraintViolationException}
      */
@@ -706,6 +895,25 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.merge(String)</code> throws an
+     * {@link javax.jcr.nodetype.ConstraintViolationException}
+     */
+/*
+    TODO: check why this fails
+    public void testMergeJcr2() throws Exception {
+        try {
+            versionManager.merge(vHistory.getPath(), workspaceName, true);
+            fail("VersionHistory.merge(String, true) did not throw an ConstraintViolationException");
+        } catch (ConstraintViolationException success) {
+        }
+        try {
+            versionManager.merge(vHistory.getPath(), workspaceName, false);
+            fail("VersionHistory.merge(String, false) did not throw an ConstraintViolationException");
+        } catch (ConstraintViolationException success) {
+        }
+    }
+*/
+    /**
      * Tests if <code>VersionHistory.orderBefore(String, String)</code> throws
      * an {@link javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -780,6 +988,25 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.restore(String, boolean)</code> and
+     * <code>VersionHistory.restore(Version, boolean)</code> throw an {@link
+     * UnsupportedRepositoryOperationException} and <code>VersionHistory.restore(Version,
+     * String, boolean)</code> throws a {@link ConstraintViolationException}.
+     */
+    public void testRestoreJcr2() throws Exception {
+        try {
+            versionManager.restore(vHistory.getPath(), "abc", true);
+            fail("VersionHistory.restore(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+        try {
+            versionManager.restore(vHistory.getPath(), version, true);
+            fail("VersionHistory.restore(Version,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.restoreByLabel(String, boolean)</code>
      * throws an {@link javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -792,6 +1019,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.restoreByLabel(String, boolean)</code>
+     * throws an {@link javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testRestoreByLabelJcr2() throws Exception {
+        try {
+            versionManager.restoreByLabel(vHistory.getPath(), "abc", true);
+            fail("VersionHistory.restoreByLabel(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <ul> <li><code>VersionHistory.setProperty(String,
      * String[])</code></li> <li><code>VersionHistory.setProperty(String,
      * String[], int)</code></li> <li><code>VersionHistory.setProperty(String,
@@ -819,37 +1058,37 @@
 
         try {
             vHistory.setProperty(propertyName1, s);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String[]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, s, PropertyType.STRING);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String[],int) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, vArray);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value[]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, vArray, PropertyType.STRING);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value[],int]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, true);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,boolean) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, 123);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,double) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -857,39 +1096,39 @@
             byte[] bytes = {73, 26, 32, -36, 40, -43, -124};
             InputStream inpStream = new ByteArrayInputStream(bytes);
             vHistory.setProperty(propertyName1, inpStream);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,InputStream) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, "abc");
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             Calendar c = new GregorianCalendar(1945, 1, 6, 16, 20, 0);
             vHistory.setProperty(propertyName1, c);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Calendar) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, testRootNode);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Node) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             Value v = superuser.getValueFactory().createValue("abc");
             vHistory.setProperty(propertyName1, v);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,Value) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             vHistory.setProperty(propertyName1, -2147483650L);
-            vHistory.save();
+            vHistory.getSession().save();
             fail("VersionHistory should be read-only: VersionHistory.setProperty(String,long) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -908,6 +1147,18 @@
     }
 
     /**
+     * Tests if <code>VersionHistory.unlock()</code> throws a {@link
+     * javax.jcr.lock.LockException}
+     */
+    public void testUnlockJcr2() throws Exception {
+        try {
+            vHistory.getSession().getWorkspace().getLockManager().unlock(vHistory.getPath());
+            fail("VersionHistory should not be lockable: VersionHistory.unlock() did not throw a LockException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.update(String)</code> throws an
      * {@link javax.jcr.nodetype.ConstraintViolationException}
      */

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionLabelTest.java Wed Jul  8 13:57:13 2009
@@ -24,6 +24,7 @@
 import javax.jcr.version.Version;
 import javax.jcr.version.VersionException;
 import javax.jcr.version.VersionHistory;
+import javax.jcr.version.VersionManager;
 
 /**
  * <code>VersionLabelTest</code> covers methods related to version label such as
@@ -61,7 +62,7 @@
 
         jcrVersionLabels = superuser.getNamespacePrefix(NS_JCR_URI) + ":versionLabels";
 
-        vHistory = versionableNode.getVersionHistory();
+        vHistory = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath());
         rootVersion = vHistory.getRootVersion();
 
         if (vHistory.hasVersionLabel(versionLabel)) {
@@ -141,6 +142,24 @@
     }
 
     /**
+     * Test if the a label added with VersionHistory.addVersionLabel(String,
+     * String, boolean) corresponds to adding a reference property to the
+     * jcr:versionLabels node of this history node, with the label as name of
+     * the property, and the reference targeting the version.
+     *
+     * @see VersionHistory#addVersionLabel(String, String, boolean)
+     */
+    public void testAddVersionCheckVersionLabelsNodeJcr2() throws RepositoryException {
+        vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+
+        // get jcr:versionLabels node
+        vHistory = versionableNode.getSession().getWorkspace().getVersionManager().getVersionHistory(versionableNode.getPath());
+        Node versionLabelNode = vHistory.getNode(jcrVersionLabels);
+
+        assertTrue("The version label that has been successfully added must be present in the node '" + jcrVersionLabels + "'.", versionLabelNode.getProperty(versionLabel).getString().equals(rootVersion.getUUID()));
+    }
+
+    /**
      * Test if VersionHistory.hasVersionLabel(String) returns true, if the label
      * has beed successfully added before.
      *
@@ -198,6 +217,27 @@
     }
 
     /**
+     * Test if VersionHistory.addVersionLabel(versionName, label, moveLabel)
+     * throws VersionException the label already exists and if moveLabel is false)
+     *
+     * @throws RepositoryException
+     */
+    public void testAddDuplicateVersionLabelJcr2() throws RepositoryException {
+        vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+        try {
+            VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+            String path = versionableNode.getPath();
+            versionManager.checkout(path);
+            Version v = versionManager.checkin(path);
+            vHistory.addVersionLabel(v.getName(), versionLabel, false);
+
+            fail("Adding a version label that already exist in the version history must throw a VersionException.");
+        } catch (VersionException e) {
+            //success
+        }
+    }
+
+    /**
      * Test if the 'moveLabel' flag moves an existing version label.
      *
      * @throws RepositoryException
@@ -220,6 +260,30 @@
     }
 
     /**
+     * Test if the 'moveLabel' flag moves an existing version label.
+     *
+     * @throws RepositoryException
+     * @see VersionHistory#addVersionLabel(String, String, boolean)  with boolan flag equals true.
+     */
+    public void testMoveLabelJcr2() throws RepositoryException {
+        vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+        try {
+            VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+            String path = versionableNode.getPath();
+            versionManager.checkout(path);
+            Version v = versionManager.checkin(path);
+            vHistory.addVersionLabel(v.getName(), versionLabel, true);
+
+            if (!vHistory.hasVersionLabel(v, versionLabel)) {
+                fail("If 'moveLabel' is true, an existing version label must be moved to the indicated version.");
+            }
+
+        } catch (VersionException e) {
+            fail("If 'moveLabel' is true, an existing version label must be moved to the indicated version.");
+        }
+    }
+
+    /**
      * Test the removal of an version label that does not exist (must throw VersionException).
      *
      * @throws RepositoryException
@@ -295,6 +359,38 @@
     }
 
     /**
+     * Test VersionHistory.getVersionLabels() returns all labels present on the version history.
+     *
+     * @throws RepositoryException
+     * @see javax.jcr.version.VersionHistory#getVersionLabels()
+     */
+    public void testGetVersionLabelsJcr2() throws RepositoryException {
+
+        HashSet testLabels = new HashSet(Arrays.asList(vHistory.getVersionLabels()));
+
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        versionManager.checkout(path);
+        Version v = versionManager.checkin(path);
+
+        vHistory.addVersionLabel(v.getName(), versionLabel, false);
+        testLabels.add(versionLabel);
+        vHistory.addVersionLabel(rootVersion.getName(), versionLabel2, false);
+        testLabels.add(versionLabel2);
+
+        String[] labels = vHistory.getVersionLabels();
+        for (int i = 0; i < labels.length; i++) {
+            String l = labels[i];
+            if (!testLabels.contains(l)) {
+                fail("VersionHistory.getVersionLabels() must only return labels, that have been added to the history.");
+            }
+            testLabels.remove(l);
+        }
+
+        assertTrue("VersionHistory.getVersionLabels() must return all labels, that have been added to the history.", testLabels.isEmpty());
+    }
+
+    /**
      * Test VersionHistory.getVersionLabels(Version) only returns all labels present
      * for the specified version.
      *
@@ -326,6 +422,39 @@
     }
 
     /**
+     * Test VersionHistory.getVersionLabels(Version) only returns all labels present
+     * for the specified version.
+     *
+     * @throws RepositoryException
+     * @see VersionHistory#getVersionLabels(javax.jcr.version.Version)
+     */
+    public void testGetVersionLabelsForVersionJcr2() throws RepositoryException {
+
+        HashSet testLabels = new HashSet(Arrays.asList(vHistory.getVersionLabels(rootVersion)));
+
+        vHistory.addVersionLabel(rootVersion.getName(), versionLabel, false);
+        testLabels.add(versionLabel);
+
+        // add a version label to another version (not added to the testLabel set)
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        versionManager.checkout(path);
+        Version v = versionManager.checkin(path);
+        vHistory.addVersionLabel(v.getName(), versionLabel2, false);
+
+        String[] labels = vHistory.getVersionLabels(rootVersion);
+        for (int i = 0; i < labels.length; i++) {
+            String l = labels[i];
+            if (!testLabels.contains(l)) {
+                fail("VersionHistory.getVersionLabels(Version) must only return labels, that have been added for this version.");
+            }
+            testLabels.remove(l);
+        }
+
+        assertTrue("VersionHistory.getVersionLabels(Version)  must return all labels, that have been added for this version.", testLabels.isEmpty());
+    }
+
+    /**
      * Test calling Node.restoreByLabel(String, boolean) on a non-versionable node.
      *
      * @throws javax.jcr.RepositoryException
@@ -341,6 +470,21 @@
     }
 
     /**
+     * Test calling Node.restoreByLabel(String, boolean) on a non-versionable node.
+     *
+     * @throws javax.jcr.RepositoryException
+     * @see javax.jcr.Node#restoreByLabel(String, boolean)
+     */
+    public void testRestoreByLabelNonVersionableNodeJcr2() throws RepositoryException {
+        try {
+            nonVersionableNode.getSession().getWorkspace().getVersionManager().restoreByLabel(nonVersionableNode.getPath(), versionLabel, true);
+            fail("Node.restoreByLabel(String, boolean) on a non versionable node must throw UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException e) {
+            //success
+        }
+    }
+
+    /**
      * Test if versionHistory.getVersionLabels(Version) throws a VersionException if the
      * specified version is not in this version history.
      */

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionStorageTest.java Wed Jul  8 13:57:13 2009
@@ -63,7 +63,7 @@
      */
     public void testVersionStorageIdenticalAcrossAllWorkspaces() throws RepositoryException {
         // The superuser session for the second workspace
-        Session superuserW2 = helper.getSuperuserSession(workspaceName);
+        Session superuserW2 = getHelper().getSuperuserSession(workspaceName);
 
         try {
             // check path to version storage

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/VersionTest.java Wed Jul  8 13:57:13 2009
@@ -19,6 +19,7 @@
 import javax.jcr.nodetype.NodeType;
 import javax.jcr.nodetype.ConstraintViolationException;
 import javax.jcr.version.Version;
+import javax.jcr.version.VersionManager;
 import javax.jcr.ItemVisitor;
 import javax.jcr.Node;
 import javax.jcr.RepositoryException;
@@ -29,6 +30,7 @@
 import javax.jcr.Value;
 import javax.jcr.PropertyType;
 import javax.jcr.lock.LockException;
+import javax.jcr.lock.LockManager;
 
 import java.util.GregorianCalendar;
 import java.util.Calendar;
@@ -48,6 +50,7 @@
  */
 public class VersionTest extends AbstractVersionTest {
 
+    private VersionManager versionManager;
     private Version version;
     private Version version2;
 
@@ -73,15 +76,17 @@
     protected void setUp() throws Exception {
         super.setUp();
 
+        versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+
         // create two versions
-        version = versionableNode.checkin();
-        versionableNode.checkout();
-        version2 = versionableNode.checkin();
+        version = versionManager.checkin(versionableNode.getPath());
+        versionManager.checkout(versionableNode.getPath());
+        version2 = versionManager.checkin(versionableNode.getPath());
     }
 
     protected void tearDown() throws Exception {
         // check the node out, so that it can be removed
-        versionableNode.checkout();
+        versionManager.checkout(versionableNode.getPath());
         version = null;
         version2 = null;
         super.tearDown();
@@ -116,13 +121,13 @@
     public void testAddNode() throws Exception {
         try {
             version.addNode(nodeName4);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.addNode(String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.addNode(nodeName4, ntBase);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.addNode(String,String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -149,6 +154,18 @@
     }
 
     /**
+     * Tests if <code>Version.cancelMerge(Version)</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCancelMergeJcr2() throws Exception {
+        try {
+            versionManager.cancelMerge(version.getPath(), version2);
+            fail("Version.cancelMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.checkin()</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -161,6 +178,18 @@
     }
 
     /**
+     * Tests if <code>Version.checkin()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCheckinJcr2() throws Exception {
+        try {
+            versionManager.checkin(version.getPath());
+            fail("Version.checkin() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.checkout()</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -173,6 +202,18 @@
     }
 
     /**
+     * Tests if <code>Version.checkout()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testCheckoutJcr2() throws Exception {
+        try {
+            versionManager.checkout(version.getPath());
+            fail("Version.checkout() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.doneMerge(Version)</code> throws an {@link
      * javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -185,6 +226,18 @@
     }
 
     /**
+     * Tests if <code>Version.doneMerge(Version)</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testDoneMergeJcr2() throws Exception {
+        try {
+            versionManager.doneMerge(version.getPath(), version2);
+            fail("Version should not be versionable: Version.doneMerge(Version) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.getAncestor(int)</code> returns the right
      * ancestor
      */
@@ -205,6 +258,18 @@
     }
 
     /**
+     * Tests if <code>Version.getBaseVersion()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testGetBaseVersionJcr2() throws Exception {
+        try {
+            versionManager.getBaseVersion(version.getPath());
+            fail("Version.getBaseVersion() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.getCorrespondingNodePath(String)</code> returns
      * the right path
      */
@@ -239,6 +304,18 @@
     }
 
     /**
+     * Tests if <code>Version.getLock()</code> throws a {@link
+     * javax.jcr.lock.LockException}
+     */
+    public void testGetLockJcr2() throws Exception {
+        try {
+            version.getSession().getWorkspace().getLockManager().getLock(version.getPath());
+            fail("Version should not be lockable: Version.getLock() did not throw a LockException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.getMixinNodeTypes()</code> does not return null.
      */
     public void testGetMixinNodeTypes() throws Exception {
@@ -356,6 +433,18 @@
     }
 
     /**
+     * Tests if <code>Version.getVersionHistory()</code> throws an {@link
+     * javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testGetVersionHistoryJcr2() throws Exception {
+        try {
+            versionManager.getVersionHistory(version.getPath());
+            fail("Version.getVersionHistory() did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.getUUID()</code> returns the right UUID
      */
     public void testGetUUID() throws Exception {
@@ -401,6 +490,13 @@
     }
 
     /**
+     * Tests if <code>Version.holdsLock()</code> returns <code>false</code>
+     */
+    public void testHoldsLockJcr2() throws Exception {
+        assertFalse("Version.holdsLock() did not return false", version.getSession().getWorkspace().getLockManager().holdsLock(version.getPath()));
+    }
+
+    /**
      * Tests if <code>Version.isCheckedOut()</code> returns <code>true</code>
      */
     public void testIsCheckedOut() throws Exception {
@@ -408,6 +504,13 @@
     }
 
     /**
+     * Tests if <code>Version.isCheckedOut()</code> returns <code>true</code>
+     */
+    public void testIsCheckedOutJcr2() throws Exception {
+        assertTrue("Version.isCheckedOut() did not return true", versionManager.isCheckedOut(version.getPath()));
+    }
+
+    /**
      * Tests if <code>Version.isLocked()</code> returns <code>false</code>
      */
     public void testIsLocked() throws Exception {
@@ -415,6 +518,13 @@
     }
 
     /**
+     * Tests if <code>Version.isLocked()</code> returns <code>false</code>
+     */
+    public void testIsLockedJcr2() throws Exception {
+        assertFalse("Version.isLocked() did not return false", version.getSession().getWorkspace().getLockManager().isLocked(version.getPath()));
+    }
+
+    /**
      * Tests if <code>Version.isModified()</code> returns <code>false</code>
      */
     public void testIsModified() throws Exception {
@@ -452,6 +562,14 @@
     }
 
     /**
+     * Tests if <code>Version.isSame()</code> returns the right
+     * <code>boolean</code> value
+     */
+    public void testIsSameJcr2() throws Exception {
+        assertTrue("Version.isSame(Item) did not return true", version2.isSame(versionManager.getBaseVersion(versionableNode.getPath())));
+    }
+
+    /**
      * Tests if <code>Version.lock(boolean, boolean)</code> throws a {@link
      * LockException}
      */
@@ -479,6 +597,35 @@
     }
 
     /**
+     * Tests if <code>Version.lock(boolean, boolean)</code> throws a {@link
+     * LockException}
+     */
+    public void testLockJcr2() throws Exception {
+        LockManager lockManager = version.getSession().getWorkspace().getLockManager();
+        String path = version.getPath();
+        try {
+            lockManager.lock(path, true, true, 60, "");
+            fail("Version should not be lockable: Version.lock(true,true) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, true, false, 60, "");
+            fail("Version should not be lockable: Version.lock(true,false) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, false, true, 60, "");
+            fail("Version should not be lockable: Version.lock(false,true) did not throw a LockException");
+        } catch (LockException success) {
+        }
+        try {
+            lockManager.lock(path, false, false, 60, "");
+            fail("Version should not be lockable: Version.lock(false,false) did not throw a LockException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.merge(String)</code> throws an
      * {@link javax.jcr.nodetype.ConstraintViolationException}
      */
@@ -496,6 +643,25 @@
     }
 
     /**
+     * Tests if <code>Version.merge(String)</code> throws an
+     * {@link javax.jcr.nodetype.ConstraintViolationException}
+     */
+/*
+    TODO: check why this fails
+    public void testMergeJcr2() throws Exception {
+        try {
+            versionManager.merge(version.getPath(), workspaceName, true);
+            fail("Version.merge(String, true) did not throw an ConstraintViolationException");
+        } catch (ConstraintViolationException success) {
+        }
+        try {
+            versionManager.merge(version.getPath(),workspaceName, false);
+            fail("Version.merge(String, false) did not throw an ConstraintViolationException");
+        } catch (ConstraintViolationException success) {
+        }
+    }
+*/
+    /**
      * Tests if <code>Version.orderBefore(String, String)</code> throws an
      * {@link javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -525,7 +691,7 @@
     public void testRemove() throws Exception {
         try {
             version.remove();
-            versionableNode.getVersionHistory().save();
+            versionableNode.getSession().save();
             fail("Version should be read-only: Version.remove() did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -569,6 +735,26 @@
     }
 
     /**
+     * Tests if <code>Version.restore(String, boolean)</code> and
+     * <code>Version.restore(Version, boolean)</code> throw an
+     * {@link UnsupportedRepositoryOperationException} and
+     * <code>Version.restore(Version, String, boolean)</code> throws a
+     * {@link ConstraintViolationException}.
+     */
+    public void testRestoreJcr2() throws Exception {
+        try {
+            versionManager.restore(version.getPath(), "abc", true);
+            fail("Version.restore(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+        try {
+            versionManager.restore(version.getPath(), version2, true);
+            fail("Version.restore(Version,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if <code>Version.restoreByLabel(String, boolean)</code> throws an
      * {@link javax.jcr.UnsupportedRepositoryOperationException}
      */
@@ -581,6 +767,18 @@
     }
 
     /**
+     * Tests if <code>Version.restoreByLabel(String, boolean)</code> throws an
+     * {@link javax.jcr.UnsupportedRepositoryOperationException}
+     */
+    public void testRestoreByLabelJcr2() throws Exception {
+        try {
+            versionManager.restoreByLabel(version.getPath(), "abc", true);
+            fail("Version.restoreByLabel(String,boolean) did not throw an UnsupportedRepositoryOperationException");
+        } catch (UnsupportedRepositoryOperationException success) {
+        }
+    }
+
+    /**
      * Tests if
      * <ul> <li><code>Version.setProperty(String, String[])</code></li>
      * <li><code>Version.setProperty(String, String[], int)</code></li>
@@ -610,37 +808,37 @@
 
         try {
             version.setProperty(propertyName1, s);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,String[]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, s, PropertyType.STRING);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,String[],int) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, vArray);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,Value[]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, vArray, PropertyType.STRING);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,Value[],int]) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, true);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,boolean) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, 123);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,double) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -648,39 +846,39 @@
             byte[] bytes = {73, 26, 32, -36, 40, -43, -124};
             InputStream inpStream = new ByteArrayInputStream(bytes);
             version.setProperty(propertyName1, inpStream);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,InputStream) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, "abc");
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,String) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             Calendar c = new GregorianCalendar(1945, 1, 6, 16, 20, 0);
             version.setProperty(propertyName1, c);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,Calendar) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, testRootNode);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,Node) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             Value v = superuser.getValueFactory().createValue("abc");
             version.setProperty(propertyName1, v);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,Value) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
         try {
             version.setProperty(propertyName1, -2147483650L);
-            version.save();
+            version.getSession().save();
             fail("Version should be read-only: Version.setProperty(String,long) did not throw a ConstraintViolationException");
         } catch (ConstraintViolationException success) {
         }
@@ -699,6 +897,18 @@
     }
 
     /**
+     * Tests if <code>Version.unlock()</code> throws a {@link
+     * javax.jcr.lock.LockException}
+     */
+    public void testUnlockJcr2() throws Exception {
+        try {
+            version.getSession().getWorkspace().getLockManager().unlock(version.getPath());
+            fail("Version should not be lockable: Version.unlock() did not throw a LockException");
+        } catch (LockException success) {
+        }
+    }
+
+    /**
      * Tests if <code>VersionHistory.update(String)</code> throws an
      * {@link javax.jcr.nodetype.ConstraintViolationException}
      */

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/WorkspaceRestoreTest.java Wed Jul  8 13:57:13 2009
@@ -22,6 +22,7 @@
 import javax.jcr.version.Version;
 import javax.jcr.version.VersionException;
 import javax.jcr.version.OnParentVersionAction;
+import javax.jcr.version.VersionManager;
 import javax.jcr.Session;
 import javax.jcr.Node;
 import javax.jcr.RepositoryException;
@@ -57,11 +58,13 @@
     protected void setUp() throws Exception {
         super.setUp();
 
-        version = versionableNode.checkin();
-        versionableNode.checkout();
-        version2 = versionableNode.checkin();
-        versionableNode.checkout();
-        rootVersion = versionableNode.getVersionHistory().getRootVersion();
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        version = versionManager.checkin(path);
+        versionManager.checkout(path);
+        version2 = versionManager.checkin(path);
+        versionManager.checkout(path);
+        rootVersion = versionManager.getVersionHistory(path).getRootVersion();
 
         // build a second versionable node below the testroot
         try {
@@ -70,7 +73,7 @@
             fail("Failed to create a second versionable node: " + e.getMessage());
         }
         try {
-            wSuperuser = helper.getSuperuserSession(workspaceName);
+            wSuperuser = getHelper().getSuperuserSession(workspaceName);
         } catch (RepositoryException e) {
             fail("Failed to retrieve superuser session for second workspace '" + workspaceName + "': " + e.getMessage());
         }
@@ -102,11 +105,11 @@
             // and check versionable nodes out.
             wTestRoot = (Node) wSuperuser.getItem(testRootNode.getPath());
 
-            wVersionableNode = wSuperuser.getNodeByUUID(versionableNode.getUUID());
-            wVersionableNode.checkout();
+            wVersionableNode = wSuperuser.getNodeByIdentifier(versionableNode.getIdentifier());
+            wVersionableNode.getSession().getWorkspace().getVersionManager().checkout(wVersionableNode.getPath());
 
-            wVersionableNode2 = wSuperuser.getNodeByUUID(versionableNode2.getUUID());
-            wVersionableNode2.checkout();
+            wVersionableNode2 = wSuperuser.getNodeByIdentifier(versionableNode2.getIdentifier());
+            wVersionableNode2.getSession().getWorkspace().getVersionManager().checkout(wVersionableNode2.getPath());
 
         } catch (RepositoryException e) {
             fail("Failed to setup test environment in workspace: " + e.toString());
@@ -121,9 +124,11 @@
         }
 
         // create a version of the versionable child node
-        wVersionableChildNode.checkout();
-        wChildVersion = wVersionableChildNode.checkin();
-        wVersionableChildNode.checkout();
+        VersionManager wVersionManager = wVersionableChildNode.getSession().getWorkspace().getVersionManager();
+        String wPath = wVersionableChildNode.getPath();
+        wVersionManager.checkout(wPath);
+        wChildVersion = wVersionManager.checkin(wPath);
+        wVersionManager.checkout(wPath);
     }
 
 
@@ -174,6 +179,27 @@
     }
 
     /**
+     * Test if InvalidItemStateException is thrown if the session affected by
+     * VersionManager.restore(Version[], boolean) has pending changes.
+     */
+    public void testWorkspaceRestoreWithPendingChangesJcr2() throws RepositoryException {
+        versionableNode.getSession().getWorkspace().getVersionManager().checkout(versionableNode.getPath());
+        try {
+            // modify node without calling save()
+            versionableNode.setProperty(propertyName1, propertyValue);
+
+            // create version in second workspace
+            Version v = wVersionableNode.getSession().getWorkspace().getVersionManager().checkin(wVersionableNode.getPath());
+            // try to restore that version
+            superuser.getWorkspace().getVersionManager().restore(new Version[]{v}, false);
+
+            fail("InvalidItemStateException must be thrown on attempt to call Workspace.restore(Version[], boolean) in a session having any unsaved changes pending.");
+        } catch (InvalidItemStateException e) {
+            // success
+        }
+    }
+
+    /**
      * Test if VersionException is thrown if the specified version array does
      * not contain a version that has a corresponding node in this workspace.
      */
@@ -187,6 +213,19 @@
     }
 
     /**
+     * Test if VersionException is thrown if the specified version array does
+     * not contain a version that has a corresponding node in this workspace.
+     */
+    public void testWorkspaceRestoreHasCorrespondingNodeJcr2() throws RepositoryException {
+        try {
+            superuser.getWorkspace().getVersionManager().restore(new Version[]{wChildVersion}, false);
+            fail("Workspace.restore(Version[], boolean) must throw VersionException if non of the specified versions has a corresponding node in the workspace.");
+        } catch (VersionException e) {
+            // success
+        }
+    }
+
+    /**
      * Test if Workspace.restore(Version[], boolean) succeeds if the following two
      * preconditions are fulfilled:<ul>
      * <li>For every version V in S that corresponds to a missing node in the workspace,
@@ -206,6 +245,25 @@
     }
 
     /**
+     * Test if VersionManager.restore(Version[], boolean) succeeds if the following two
+     * preconditions are fulfilled:<ul>
+     * <li>For every version V in S that corresponds to a missing node in the workspace,
+     * there must also be a parent of V in S.</li>
+     * <li>S must contain at least one version that corresponds to an existing
+     * node in the workspace.</li>
+     * </ul>
+     */
+    public void testWorkspaceRestoreWithParentJcr2() throws RepositoryException {
+
+        try {
+            Version parentV = wVersionableNode.getSession().getWorkspace().getVersionManager().checkin(wVersionableNode.getPath());
+            superuser.getWorkspace().getVersionManager().restore(new Version[]{parentV, wChildVersion}, false);
+        } catch (RepositoryException e) {
+            fail("Workspace.restore(Version[], boolean) with a version that has no corresponding node must succeed if a version of a parent with correspondance is present in the version array.");
+        }
+    }
+
+    /**
      * Test if the removeExisting-flag removes an existing node in case of uuid conflict.
      */
     public void testWorkspaceRestoreWithRemoveExisting() throws NotExecutableException, RepositoryException {
@@ -227,6 +285,27 @@
     }
 
     /**
+     * Test if the removeExisting-flag removes an existing node in case of uuid conflict.
+     */
+    public void testWorkspaceRestoreWithRemoveExistingJcr2() throws NotExecutableException, RepositoryException {
+        // create version for parentNode of childNode
+        superuser.getWorkspace().clone(workspaceName, wVersionableChildNode.getPath(), wVersionableChildNode.getPath(), false);
+        Version parentV = versionableNode.getSession().getWorkspace().getVersionManager().checkin(versionableNode.getPath());
+
+        // move child node in order to produce the uuid conflict
+        String newChildPath = wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName();
+        wSuperuser.move(wVersionableChildNode.getPath(), newChildPath);
+        wSuperuser.save();
+
+        // restore the parent with removeExisting == true >> moved child node
+        // must be removed.
+        wSuperuser.getWorkspace().getVersionManager().restore(new Version[]{parentV}, true);
+        if (wSuperuser.itemExists(newChildPath)) {
+            fail("Workspace.restore(Version[], boolean) with the boolean flag set to true, must remove the existing node in case of Uuid conflict.");
+        }
+    }
+
+    /**
      * Tests if restoring the <code>Version</code> of an existing node throws an
      * <code>ItemExistsException</code> if removeExisting is set to FALSE.
      */
@@ -250,6 +329,32 @@
         }
     }
 
+    /**
+     * Tests if restoring the <code>Version</code> of an existing node throws an
+     * <code>ItemExistsException</code> if removeExisting is set to FALSE.
+     */
+    public void testWorkspaceRestoreWithUUIDConflictJcr2() throws RepositoryException, NotExecutableException {
+        try {
+            // Verify that nodes used for the test are indeed versionable
+            NodeDefinition nd = wVersionableNode.getDefinition();
+            if (nd.getOnParentVersion() != OnParentVersionAction.COPY && nd.getOnParentVersion() != OnParentVersionAction.VERSION) {
+                throw new NotExecutableException("Nodes must be versionable in order to run this test.");
+            }
+
+            VersionManager versionManager = wVersionableNode.getSession().getWorkspace().getVersionManager();
+            String path = wVersionableNode.getPath();
+            Version v = versionManager.checkin(path);
+            versionManager.checkout(path);
+            wSuperuser.move(wVersionableChildNode.getPath(), wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName());
+            wSuperuser.save();
+            wSuperuser.getWorkspace().getVersionManager().restore(new Version[]{v}, false);
+
+            fail("Node.restore( Version, boolean ): An ItemExistsException must be thrown if the node to be restored already exsits and removeExisting was set to false.");
+        } catch (ItemExistsException e) {
+            // success
+        }
+    }
+
 
     /**
      * Test if workspace-restoring a node works on checked-in node.
@@ -262,6 +367,18 @@
     }
 
     /**
+     * Test if workspace-restoring a node works on checked-in node.
+     */
+    public void testWorkspaceRestoreOnCheckedInNodeJcr2() throws RepositoryException {
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        if (versionManager.isCheckedOut(path)) {
+            versionManager.checkin(path);
+        }
+        superuser.getWorkspace().getVersionManager().restore(new Version[]{version}, true);
+    }
+
+    /**
      * Test if workspace-restoring a node works on checked-out node.
      */
     public void testWorkspaceRestoreOnCheckedOutNode() throws RepositoryException {
@@ -271,4 +388,15 @@
         superuser.getWorkspace().restore(new Version[]{version}, true);
     }
 
+    /**
+     * Test if workspace-restoring a node works on checked-out node.
+     */
+    public void testWorkspaceRestoreOnCheckedOutNodeJcr2() throws RepositoryException {
+        VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
+        String path = versionableNode.getPath();
+        if (!versionManager.isCheckedOut(path)) {
+            versionManager.checkout(path);
+        }
+        superuser.getWorkspace().getVersionManager().restore(new Version[]{version}, true);
+    }
 }

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/AbstractVersionTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/AbstractVersionTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/AbstractVersionTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/AbstractVersionTest.java Wed Jul  8 13:57:13 2009
@@ -24,6 +24,7 @@
 import javax.jcr.version.VersionHistory;
 
 import org.apache.jackrabbit.test.AbstractJCRTest;
+import org.apache.jackrabbit.test.NotExecutableException;
 
 /**
  * <code>AbstractVersionTest</code> is the abstract base class for all
@@ -132,11 +133,10 @@
      * @return versionable node.
      * @throws RepositoryException
      */
-    protected Node createVersionableNode(Node parent, String name, NodeType nodetype) throws RepositoryException {
+    protected Node createVersionableNode(Node parent, String name, NodeType nodetype)
+            throws RepositoryException, NotExecutableException {
         Node versionableNode = parent.addNode(name, nodetype.getName());
-        if (!nodetype.isNodeType(mixSimpleVersionable)) {
-            versionableNode.addMixin(mixSimpleVersionable);
-        }
+        ensureMixinType(versionableNode, mixSimpleVersionable);
         parent.getSession().save();
 
         return versionableNode;

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/CopyTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/CopyTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/CopyTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/CopyTest.java Wed Jul  8 13:57:13 2009
@@ -28,10 +28,10 @@
  * 15.1.4 Copying Versionable Nodes and Version Lineage
  * Under both simple and full versioning, when an existing versionable node N is
  * copied to a new location either in the same workspace or another, and the
- * repository preserves the versionable mixin (see �10.7.4 Dropping Mixins on
+ * repository preserves the versionable mixin (see 10.7.4 Dropping Mixins on
  * Copy):
- * ? A copy of N, call it M, is created, as usual.
- * ? A new, empty, version history for M, call it HM, is also created.
+ * - A copy of N, call it M, is created, as usual.
+ * - A new, empty, version history for M, call it HM, is also created.
  *
  * @test
  * @sources CopyTest.java

Modified: jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/FrozenNodeTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/FrozenNodeTest.java?rev=792142&r1=792141&r2=792142&view=diff
==============================================================================
--- jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/FrozenNodeTest.java (original)
+++ jackrabbit/sandbox/JCR-1456/jackrabbit-jcr-tests/src/main/java/org/apache/jackrabbit/test/api/version/simple/FrozenNodeTest.java Wed Jul  8 13:57:13 2009
@@ -21,6 +21,8 @@
 import javax.jcr.version.Version;
 import javax.jcr.version.VersionManager;
 
+import org.apache.jackrabbit.test.NotExecutableException;
+
 /**
  * <code>SVFrozenNodeTest</code> covers tests related to frozen nodes in
  * simple versioning
@@ -71,9 +73,10 @@
     /**
      * @throws RepositoryException
      */
-    public void testFrozenUUUID() throws RepositoryException {
+    public void testFrozenUUUID() throws RepositoryException,
+            NotExecutableException {
         // make versionable node referenceable
-        versionableNode.addMixin(mixReferenceable);
+        ensureMixinType(versionableNode, mixReferenceable);
         versionableNode.getSession().save();
         VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
         String path = versionableNode.getPath();
@@ -87,9 +90,10 @@
     /**
      * @throws RepositoryException
      */
-    public void testFrozenChildUUUID() throws RepositoryException {
+    public void testFrozenChildUUUID() throws RepositoryException,
+            NotExecutableException {
         Node n1 = versionableNode.addNode("child");
-        n1.addMixin(mixReferenceable);
+        ensureMixinType(n1, mixReferenceable);
         versionableNode.getSession().save();
         VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
         String path = versionableNode.getPath();



Mime
View raw message