Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/BitsetENTCacheImpl.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/BitsetENTCacheImpl.java	(revision 631472)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/BitsetENTCacheImpl.java	(working copy)
@@ -16,14 +16,14 @@
  */
 package org.apache.jackrabbit.core.nodetype;
 
-import org.apache.jackrabbit.spi.Name;
-
-import java.util.TreeSet;
+import java.io.PrintStream;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.ArrayList;
-import java.io.PrintStream;
+import java.util.TreeSet;
 
+import org.apache.jackrabbit.spi.Name;
+
 import EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap;
 
 /**
@@ -50,12 +50,12 @@
     /**
      * An ordered set of the keys. This is used for {@link #findBest(Key)}.
      */
-    private final TreeSet sortedKeys;
+    private TreeSet sortedKeys;
 
     /**
      * cache of pre-built aggregations of node types
      */
-    private final HashMap aggregates;
+    private HashMap aggregates;
 
     /**
      * A lookup table for bit numbers for a given name.
@@ -64,7 +64,7 @@
      * be stored in the node type registry since only registered node type names
      * are allowed in the keys.
      */
-    private final ConcurrentReaderHashMap nameIndex = new ConcurrentReaderHashMap();
+    private ConcurrentReaderHashMap nameIndex = new ConcurrentReaderHashMap();
 
     /**
      * The reverse lookup table for bit numbers to names
@@ -210,13 +210,21 @@
      * {@inheritDoc}
      */
     public Object clone() {
-        BitsetENTCacheImpl clone = new BitsetENTCacheImpl();
-        clone.sortedKeys.addAll(sortedKeys);
-        clone.aggregates.putAll(aggregates);
-        clone.names = new Name[names.length];
-        System.arraycopy(names, 0, clone.names, 0, names.length);
-        clone.nameIndex.putAll(nameIndex);
-        return clone;
+    	try {
+    	    BitsetENTCacheImpl clone = (BitsetENTCacheImpl)super.clone();
+    	    clone.sortedKeys = new TreeSet();
+    	    clone.aggregates = new HashMap();
+    		clone.sortedKeys.addAll(sortedKeys);
+    		clone.aggregates.putAll(aggregates);
+    		clone.names = new Name[names.length];
+    		System.arraycopy(names, 0, clone.names, 0, names.length);
+    		clone.nameIndex = new ConcurrentReaderHashMap();
+    		clone.nameIndex.putAll(nameIndex);
+    		return clone;
+       } catch (CloneNotSupportedException e) {
+    	   //Won't happen
+    		throw new InternalError("Failed to clone BitsetENTCacheImpl");
+       }
     }
 
     /**
Index: jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/NodeTypeDef.java
===================================================================
--- jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/NodeTypeDef.java	(revision 631472)
+++ jackrabbit-core/src/main/java/org/apache/jackrabbit/core/nodetype/NodeTypeDef.java	(working copy)
@@ -308,16 +308,15 @@
 
     //-------------------------------------------< java.lang.Object overrides >
     public Object clone() {
-        NodeTypeDef clone = new NodeTypeDef();
-        clone.name = name;
-        clone.primaryItemName = primaryItemName;
-        clone.supertypes = supertypes; // immutable, thus ok to share
-        clone.mixin = mixin;
-        clone.orderableChildNodes = orderableChildNodes;
-        clone.abstractStatus = abstractStatus;
-        clone.nodeDefs = (HashSet) nodeDefs.clone();
-        clone.propDefs = (HashSet) propDefs.clone();
-        return clone;
+    	try {
+    		NodeTypeDef clone = (NodeTypeDef)super.clone();
+    		clone.nodeDefs = (HashSet) nodeDefs.clone();
+    		clone.propDefs = (HashSet) propDefs.clone();
+    		clone.dependencies = null;
+    		return clone;
+    	} catch (CloneNotSupportedException e) {
+        	//won't happen
+      		throw new InternalError("Failed to clone NodeTypeDef object");
+    	}
     }
 
     public boolean equals(Object obj) {
Index: jackrabbit-jcr2spi/src/main/java/org/apache/jackrabbit/jcr2spi/nodetype/EffectiveNodeTypeImpl.java
===================================================================
--- jackrabbit-jcr2spi/src/main/java/org/apache/jackrabbit/jcr2spi/nodetype/EffectiveNodeTypeImpl.java	(revision 631472)
+++ jackrabbit-jcr2spi/src/main/java/org/apache/jackrabbit/jcr2spi/nodetype/EffectiveNodeTypeImpl.java	(working copy)
@@ -48,16 +48,16 @@
     private static Logger log = LoggerFactory.getLogger(EffectiveNodeTypeImpl.class);
 
     // list of explicitly aggregated {i.e. merged) node types
-    private final TreeSet mergedNodeTypes;
+    private TreeSet mergedNodeTypes;
     // list of implicitly aggregated {through inheritance) node types
-    private final TreeSet inheritedNodeTypes;
+    private TreeSet inheritedNodeTypes;
     // list of all either explicitly (through aggregation) or implicitly
     // (through inheritance) included node types.
-    private final TreeSet allNodeTypes;
+    private TreeSet allNodeTypes;
     // map of named item definitions (maps name to list of definitions)
-    private final HashMap namedItemDefs;
+    private HashMap namedItemDefs;
     // list of unnamed item definitions (i.e. residual definitions)
-    private final ArrayList unnamedItemDefs;
+    private ArrayList unnamedItemDefs;
 
     /**
      * private constructor.
@@ -798,19 +798,28 @@
     }
 
     protected Object clone() {
-        EffectiveNodeTypeImpl clone = new EffectiveNodeTypeImpl();
-
-        clone.mergedNodeTypes.addAll(mergedNodeTypes);
-        clone.inheritedNodeTypes.addAll(inheritedNodeTypes);
-        clone.allNodeTypes.addAll(allNodeTypes);
-        Iterator iter = namedItemDefs.keySet().iterator();
-        while (iter.hasNext()) {
-            Object key = iter.next();
-            List list = (List) namedItemDefs.get(key);
-            clone.namedItemDefs.put(key, new ArrayList(list));
-        }
-        clone.unnamedItemDefs.addAll(unnamedItemDefs);
-
-        return clone;
+    	try {
+    		EffectiveNodeTypeImpl clone = (EffectiveNodeTypeImpl)super.clone();
+    		clone.mergedNodeTypes = new TreeSet();
+    		clone.mergedNodeTypes.addAll(mergedNodeTypes);
+    		clone.inheritedNodeTypes = new TreeSet();
+    		clone.inheritedNodeTypes.addAll(inheritedNodeTypes);
+    		clone.allNodeTypes = new TreeSet();
+    		clone.allNodeTypes.addAll(allNodeTypes);
+    		clone.namedItemDefs = new HashMap();
+    		Iterator iter = namedItemDefs.keySet().iterator();
+    		while (iter.hasNext()) {
+    		Object key = iter.next();
+    			List list = (List) namedItemDefs.get(key);
+    			clone.namedItemDefs.put(key, new ArrayList(list));
+    		}
+    		clone.unnamedItemDefs = new ArrayList();
+    		clone.unnamedItemDefs.addAll(unnamedItemDefs);
+    		
+    		return clone;
+    	} catch (CloneNotSupportedException e) {
+    		//won't happen
+    		throw new InternalError("Failed to clone EffectiveNodeTypeImpl");
+    	}
     }
 }