Description: Cumulative patch from Jenkins fork of xstream for application
 to stock xstream.
Author: James Page <james.page@canonical.com>
Origin: https://github.com/jenkinsci/xstream/commits/1.3.1-hudson-8

diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/XStream.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/XStream.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/XStream.java	2008-12-06 15:47:56.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/XStream.java	2010-10-09 18:20:48.000000000 +0100
@@ -202,7 +202,7 @@ import java.util.Vector;
  * no other registered converter is suitable, can be registered with priority
  * XStream.PRIORITY_VERY_LOW. XStream uses by default the
  * {@link com.thoughtworks.xstream.converters.reflection.ReflectionConverter} as the fallback
- * converter.
+ * converter (override createDefaultConverter() to change this).
  * </p>
  * <p/>
  * <p>
@@ -612,10 +612,13 @@ public class XStream {
         addDefaultImplementation(GregorianCalendar.class, Calendar.class);
     }
 
+    protected Converter createDefaultConverter() {
+        return new ReflectionConverter(mapper, reflectionProvider);
+    }
+
     protected void setupConverters() {
-        final ReflectionConverter reflectionConverter = 
-            new ReflectionConverter(mapper, reflectionProvider);
-        registerConverter(reflectionConverter, PRIORITY_VERY_LOW);
+        final Converter defaultConverter = createDefaultConverter();
+        registerConverter(defaultConverter, PRIORITY_VERY_LOW);
 
         registerConverter(new SerializableConverter(mapper, reflectionProvider), PRIORITY_LOW);
         registerConverter(new ExternalizableConverter(mapper), PRIORITY_LOW);
@@ -675,7 +678,7 @@ public class XStream {
             dynamicallyRegisterConverter(
                     "com.thoughtworks.xstream.converters.extended.ThrowableConverter",
                     PRIORITY_NORMAL, new Class[]{Converter.class},
-                    new Object[]{reflectionConverter});
+                    new Object[]{defaultConverter});
             dynamicallyRegisterConverter(
                     "com.thoughtworks.xstream.converters.extended.StackTraceElementConverter",
                     PRIORITY_NORMAL, null, null);
@@ -685,7 +688,7 @@ public class XStream {
             dynamicallyRegisterConverter(
                     "com.thoughtworks.xstream.converters.extended.RegexPatternConverter",
                     PRIORITY_NORMAL, new Class[]{Converter.class},
-                    new Object[]{reflectionConverter});
+                    new Object[]{defaultConverter});
             dynamicallyRegisterConverter(
                     "com.thoughtworks.xstream.converters.extended.CharsetConverter",
                     PRIORITY_NORMAL, null, null);
@@ -713,7 +716,7 @@ public class XStream {
                 null, null);
         }
 
-        registerConverter(new SelfStreamingInstanceChecker(reflectionConverter, this), PRIORITY_NORMAL);
+        registerConverter(new SelfStreamingInstanceChecker(defaultConverter, this), PRIORITY_NORMAL);
     }
 
     private void dynamicallyRegisterConverter(
@@ -1221,6 +1224,14 @@ public class XStream {
         return converterLookup;
     }
 
+    public ConverterRegistry getConverterRegistry() {
+        return converterRegistry;
+    }
+
+    public JVM getJvm() {
+        return jvm;
+    }
+
     /**
      * Change mode for dealing with duplicate references. Valid values are
      * <code>XPATH_ABSOLUTE_REFERENCES</code>, <code>XPATH_RELATIVE_REFERENCES</code>,
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializable.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializable.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializable.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializable.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,14 @@
+package com.thoughtworks.xstream.annotations;
+
+import static java.lang.annotation.ElementType.FIELD;
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import java.lang.annotation.Target;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+@Retention(RUNTIME)
+@Target(FIELD)
+public @interface XStreamSerializable {
+}
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializeAs.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializeAs.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializeAs.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/annotations/XStreamSerializeAs.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,25 @@
+package com.thoughtworks.xstream.annotations;
+
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+import static java.lang.annotation.RetentionPolicy.*;
+
+/**
+ * Designates that the type and its derived types will serialize
+ * as the specified type. This is useful if you want an entire
+ * family of types serialize as the base type with its special converter.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+@Retention(RUNTIME)
+@Target(TYPE)
+@Inherited
+public @interface XStreamSerializeAs {
+    /**
+     * Use {@code void.class} to cancel out the annotation defined in the super type.
+     */
+    Class<?> value();
+}
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/basic/StringConverter.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/basic/StringConverter.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/basic/StringConverter.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/basic/StringConverter.java	2010-10-09 18:20:48.000000000 +0100
@@ -11,6 +11,8 @@
  */
 package com.thoughtworks.xstream.converters.basic;
 
+import com.thoughtworks.xstream.core.util.ConcurrentWeakHashMap;
+
 import java.lang.ref.WeakReference;
 import java.util.Collections;
 import java.util.Map;
@@ -42,7 +44,7 @@ public class StringConverter extends Abs
     }
 
     public StringConverter() {
-        this(Collections.synchronizedMap(new WeakHashMap()));
+        this(new ConcurrentWeakHashMap());
     }
 
     public boolean canConvert(final Class type) {
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/enums/EnumConverter.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/enums/EnumConverter.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/enums/EnumConverter.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/enums/EnumConverter.java	2010-10-09 18:20:48.000000000 +0100
@@ -44,7 +44,17 @@ public class EnumConverter implements Co
         if (type.getSuperclass() != Enum.class) {
             type = type.getSuperclass(); // polymorphic enums
         }
-        return Enum.valueOf(type, reader.getValue());
+        String name = reader.getValue();
+        try {
+            return Enum.valueOf(type, name);
+        } catch (IllegalArgumentException e) {
+            // failed to find it, do a case insensitive match
+            for (Enum c : (Enum[])type.getEnumConstants())
+                if (c.name().equalsIgnoreCase(name))
+                    return c;
+            // all else failed
+            throw e;
+        }
     }
 
 }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/FieldDictionary.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/FieldDictionary.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/FieldDictionary.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/FieldDictionary.java	2010-10-09 18:20:48.000000000 +0100
@@ -23,6 +23,7 @@ import java.util.WeakHashMap;
 
 import com.thoughtworks.xstream.core.JVM;
 import com.thoughtworks.xstream.core.util.OrderRetainingMap;
+import com.thoughtworks.xstream.core.util.ConcurrentWeakHashMap;
 
 
 /**
@@ -34,8 +35,19 @@ import com.thoughtworks.xstream.core.uti
  */
 public class FieldDictionary {
 
-    private transient Map keyedByFieldNameCache;
-    private transient Map keyedByFieldKeyCache;
+    static final class Entry {
+        final Map<String,Field> keyedByFieldName;
+        final Map<FieldKey,Field> keyedByFieldKey;
+
+        Entry(Map keyedByFieldName, Map keyedByFieldKey) {
+            this.keyedByFieldName = keyedByFieldName;
+            this.keyedByFieldKey = keyedByFieldKey;
+        }
+    }
+
+    private transient Map<Class,Entry> cache;
+//    private transient Map keyedByFieldNameCache;
+//    private transient Map keyedByFieldKeyCache;
     private final FieldKeySorter sorter;
 
     public FieldDictionary() {
@@ -48,10 +60,12 @@ public class FieldDictionary {
     }
 
     private void init() {
-        keyedByFieldNameCache = new WeakHashMap();
-        keyedByFieldKeyCache = new WeakHashMap();
-        keyedByFieldNameCache.put(Object.class, Collections.EMPTY_MAP);
-        keyedByFieldKeyCache.put(Object.class, Collections.EMPTY_MAP);
+//        keyedByFieldNameCache = new WeakHashMap();
+//        keyedByFieldKeyCache = new WeakHashMap();
+//        keyedByFieldNameCache.put(Object.class, Collections.EMPTY_MAP);
+//        keyedByFieldKeyCache.put(Object.class, Collections.EMPTY_MAP);
+        cache = new ConcurrentWeakHashMap<Class,Entry>();
+        cache.put(Object.class, new Entry(Collections.EMPTY_MAP,Collections.EMPTY_MAP));
     }
 
     /**
@@ -87,20 +101,28 @@ public class FieldDictionary {
      * @return the field itself
      */
     public Field field(Class cls, String name, Class definedIn) {
-        Map fields = buildMap(cls, definedIn != null);
-        Field field = (Field)fields.get(definedIn != null ? (Object)new FieldKey(
-            name, definedIn, 0) : (Object)name);
+        Field field = fieldOrNull(cls,name,definedIn);
         if (field == null) {
-            throw new ObjectAccessException("No such field " + cls.getName() + "." + name);
+            throw new NonExistentFieldException("No such field " + cls.getName() + "." + name,name);
         } else {
             return field;
         }
     }
 
+    /**
+     * Works like {@link #field(Class, String, Class)} but returns null instead of throwing exception.
+     */
+    public Field fieldOrNull(Class cls, String name, Class definedIn) {
+        Map fields = buildMap(cls, definedIn != null);
+        Field field = (Field)fields.get(definedIn != null ? (Object)new FieldKey(
+            name, definedIn, 0) : (Object)name);
+        return field;
+    }
+
     private Map buildMap(final Class type, boolean tupleKeyed) {
         Class cls = type;
-        synchronized (this) {
-            if (!keyedByFieldNameCache.containsKey(type)) {
+//        synchronized (this) {
+            if (!cache.containsKey(type)) {
                 final List superClasses = new ArrayList();
                 while (!Object.class.equals(cls)) {
                     superClasses.add(0, cls);
@@ -110,7 +132,7 @@ public class FieldDictionary {
                 Map lastKeyedByFieldKey = Collections.EMPTY_MAP;
                 for (final Iterator iter = superClasses.iterator(); iter.hasNext();) {
                     cls = (Class)iter.next();
-                    if (!keyedByFieldNameCache.containsKey(cls)) {
+                    if (!cache.containsKey(cls)) {
                         final Map keyedByFieldName = new HashMap(lastKeyedByFieldName);
                         final Map keyedByFieldKey = new OrderRetainingMap(lastKeyedByFieldKey);
                         Field[] fields = cls.getDeclaredFields();
@@ -137,16 +159,20 @@ public class FieldDictionary {
                             }
                             keyedByFieldKey.put(fieldKey, field);
                         }
-                        keyedByFieldNameCache.put(cls, keyedByFieldName);
-                        keyedByFieldKeyCache.put(cls, sorter.sort(type, keyedByFieldKey));
+                        cache.put(cls, new Entry(keyedByFieldName,sorter.sort(type, keyedByFieldKey)));
                     }
-                    lastKeyedByFieldName = (Map)keyedByFieldNameCache.get(cls);
-                    lastKeyedByFieldKey = (Map)keyedByFieldKeyCache.get(cls);
+                    Entry e = cache.get(cls);
+                    lastKeyedByFieldName = e.keyedByFieldName;
+                    lastKeyedByFieldKey = e.keyedByFieldKey;
                 }
             }
-        }
-        return (Map)(tupleKeyed ? keyedByFieldKeyCache.get(type) : keyedByFieldNameCache
-            .get(type));
+//        }
+
+        Entry e = cache.get(type);
+        return tupleKeyed ? e.keyedByFieldKey : e.keyedByFieldName;
+
+//        return (Map)(tupleKeyed ? keyedByFieldKeyCache.get(type) : keyedByFieldNameCache
+//            .get(type));
     }
 
     protected Object readResolve() {
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/HarmonyReflectionProvider.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/HarmonyReflectionProvider.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/HarmonyReflectionProvider.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/HarmonyReflectionProvider.java	1970-01-01 01:00:00.000000000 +0100
@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2008 XStream Committers.
- * All rights reserved.
- *
- * The software in this package is published under the terms of the BSD
- * style license a copy of which has been included with this distribution in
- * the LICENSE.txt file.
- * 
- * Created on 09. January 2008 by Joerg Schaible
- */
-package com.thoughtworks.xstream.converters.reflection;
-
-import org.apache.harmony.misc.accessors.ObjectAccessor;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-
-/**
- * Instantiates a new object on the Harmony JVM by bypassing the constructor (meaning code in
- * the constructor will never be executed and parameters do not have to be known). This is the
- * same method used by the internals of standard Java serialization, but relies on internal Harmony
- * code.
- * 
- * Note, this is work in progress. Harmony 5.0M4 crashes instantiating a class derived from
- * {@link com.thoughtworks.acceptance.objects.StandardObject}, of type 
- * {@link javax.swing.JTable} or {@link java.awt.Font}. Additionally it fails with a NPE processing the
- * annotations and has a wrong offset dealing with time zone. Same problems apply to 5.0M5.
- *
- * @author J&ouml;rg Schaible
- * @author Joe Walnes
- */
-public class HarmonyReflectionProvider extends PureJavaReflectionProvider {
-    private final static ObjectAccessor objectAccess;
-    private final static Exception exception;
-    static {
-        ObjectAccessor accessor = null;
-        Exception ex = null;
-        Method method;
-        try {
-            method = ObjectAccessor.class.getDeclaredMethod("getInstance");
-            method.setAccessible(true);
-            accessor = (ObjectAccessor)method.invoke(null, null);
-        } catch (NoSuchMethodException e) {
-            ex = e;
-        } catch (IllegalAccessException e) {
-            ex = e;
-        } catch (InvocationTargetException e) {
-            ex = e;
-        }
-        objectAccess = accessor;
-        exception = ex;
-    }
-
-    public HarmonyReflectionProvider() {
-        super();
-    }
-
-    public HarmonyReflectionProvider(FieldDictionary dic) {
-        super(dic);
-    }
-
-    public Object newInstance(Class type) {
-        if (exception != null) {
-            throw new ObjectAccessException("Cannot construct " + type.getName(), exception);
-        }
-        try {
-            return objectAccess.newInstance(type);
-        } catch (SecurityException e) {
-            throw new ObjectAccessException("Cannot construct " + type.getName(), e);
-        } catch (IllegalArgumentException e) {
-            throw new ObjectAccessException("Cannot construct " + type.getName(), e);
-        }
-    }
-
-    public void writeField(Object object, String fieldName, Object value, Class definedIn) {
-        write(fieldDictionary.field(object.getClass(), fieldName, definedIn), object, value);
-    }
-
-    private void write(Field field, Object object, Object value) {
-        if (exception != null) {
-            throw new ObjectAccessException("Could not set field "
-                + object.getClass()
-                + "."
-                + field.getName(), exception);
-        }
-        try {
-            long offset = objectAccess.getFieldID(field);
-            Class type = field.getType();
-            if (type.isPrimitive()) {
-                if (type.equals(Integer.TYPE)) {
-                    objectAccess.setInt(object, offset, ((Integer)value).intValue());
-                } else if (type.equals(Long.TYPE)) {
-                    objectAccess.setLong(object, offset, ((Long)value).longValue());
-                } else if (type.equals(Short.TYPE)) {
-                    objectAccess.setShort(object, offset, ((Short)value).shortValue());
-                } else if (type.equals(Character.TYPE)) {
-                    objectAccess.setChar(object, offset, ((Character)value).charValue());
-                } else if (type.equals(Byte.TYPE)) {
-                    objectAccess.setByte(object, offset, ((Byte)value).byteValue());
-                } else if (type.equals(Float.TYPE)) {
-                    objectAccess.setFloat(object, offset, ((Float)value).floatValue());
-                } else if (type.equals(Double.TYPE)) {
-                    objectAccess.setDouble(object, offset, ((Double)value).doubleValue());
-                } else if (type.equals(Boolean.TYPE)) {
-                    objectAccess.setBoolean(object, offset, ((Boolean)value).booleanValue());
-                } else {
-                    throw new ObjectAccessException("Could not set field "
-                        + object.getClass()
-                        + "."
-                        + field.getName()
-                        + ": Unknown type "
-                        + type);
-                }
-            } else {
-                objectAccess.setObject(object, offset, value);
-            }
-
-        } catch (IllegalArgumentException e) {
-            throw new ObjectAccessException("Could not set field "
-                + object.getClass()
-                + "."
-                + field.getName(), e);
-        }
-    }
-
-    protected void validateFieldAccess(Field field) {
-        // (overriden) don't mind final fields.
-    }
-}
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/NonExistentFieldException.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/NonExistentFieldException.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/NonExistentFieldException.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/NonExistentFieldException.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,24 @@
+package com.thoughtworks.xstream.converters.reflection;
+
+/**
+ * Indicates that field/property didn't exist in classes (as opposed to what's implied in XML.)
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class NonExistentFieldException extends ObjectAccessException {
+    private final String fieldName;
+
+    public NonExistentFieldException(String message, String fieldName) {
+        super(message);
+        this.fieldName = fieldName;
+    }
+
+    public NonExistentFieldException(String message, Throwable cause, String fieldName) {
+        super(message, cause);
+        this.fieldName = fieldName;
+    }
+
+    public String getFieldName() {
+        return fieldName;
+    }
+}
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/PureJavaReflectionProvider.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/PureJavaReflectionProvider.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/PureJavaReflectionProvider.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/PureJavaReflectionProvider.java	2010-10-09 18:20:48.000000000 +0100
@@ -12,6 +12,7 @@
 package com.thoughtworks.xstream.converters.reflection;
 
 import com.thoughtworks.xstream.core.JVM;
+import com.thoughtworks.xstream.annotations.XStreamSerializable;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -152,17 +153,14 @@ public class PureJavaReflectionProvider
     }
 
     public boolean fieldDefinedInClass(String fieldName, Class type) {
-        try {
-            Field field = fieldDictionary.field(type, fieldName, null);
-            return fieldModifiersSupported(field) || Modifier.isTransient(field.getModifiers());
-        } catch (ObjectAccessException e) {
-            return false;
-        }
+        Field field = fieldDictionary.fieldOrNull(type, fieldName, null);
+        if(field==null)     return false;
+        return fieldModifiersSupported(field) || Modifier.isTransient(field.getModifiers());
     }
 
     protected boolean fieldModifiersSupported(Field field) {
         return !(Modifier.isStatic(field.getModifiers())
-                || Modifier.isTransient(field.getModifiers()));
+                || (Modifier.isTransient(field.getModifiers()) && field.getAnnotation(XStreamSerializable.class)==null));
     }
 
     protected void validateFieldAccess(Field field) {
@@ -180,6 +178,10 @@ public class PureJavaReflectionProvider
         return fieldDictionary.field(definedIn, fieldName, null);
     }
 
+    public Field getFieldOrNull(Class definedIn, String fieldName) {
+        return fieldDictionary.fieldOrNull(definedIn, fieldName,  null);
+    }
+
     public void setFieldDictionary(FieldDictionary dictionary) {
         this.fieldDictionary = dictionary;
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProvider.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProvider.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProvider.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProvider.java	2010-10-09 18:20:48.000000000 +0100
@@ -60,4 +60,10 @@ public interface ReflectionProvider {
      */
 	Field getField(Class definedIn, String fieldName);
 
+    /**
+     * Works like {@link #getField(Class, String)} but returns null
+     * instead of throwing {@link ObjectAccessException}.
+     */
+    Field getFieldOrNull(Class definedIn, String fieldName);
+
 }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProviderWrapper.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProviderWrapper.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProviderWrapper.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/ReflectionProviderWrapper.java	2010-10-09 18:20:48.000000000 +0100
@@ -50,4 +50,7 @@ public class ReflectionProviderWrapper i
         this.wrapped.writeField(object, fieldName, value, definedIn);
     }
 
+    public Field getFieldOrNull(Class definedIn, String fieldName) {
+        return this.wrapped.getFieldOrNull(definedIn,fieldName);
+    }
 }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializableConverter.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializableConverter.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializableConverter.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializableConverter.java	2010-10-09 18:20:48.000000000 +0100
@@ -320,8 +320,8 @@ public class SerializableConverter exten
                             } else {
                                 ObjectStreamField field = objectStreamClass.getField(name);
                                 if (field == null) {
-                                    throw new ObjectAccessException("Class " + currentType[0]
-                                            + " does not contain a field named '" + name + "'");
+                                    throw new NonExistentFieldException("Class " + currentType[0]
+                                            + " does not contain a field named '" + name + "'",name);
                                 }
                                 type = field.getType();
                             }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializationMethodInvoker.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializationMethodInvoker.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializationMethodInvoker.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/SerializationMethodInvoker.java	2010-10-09 18:20:48.000000000 +0100
@@ -20,6 +20,7 @@ import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Convenience wrapper to invoke special serialization methods on objects (and perform reflection caching).
@@ -28,7 +29,7 @@ import java.util.Map;
  */
 public class SerializationMethodInvoker {
 
-    private Map cache = Collections.synchronizedMap(new HashMap());
+    private Map cache = new ConcurrentHashMap();
     private static final Object NO_METHOD = new Object();
     private static final Object[] EMPTY_ARGS = new Object[0];
 
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/Sun14ReflectionProvider.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/Sun14ReflectionProvider.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/converters/reflection/Sun14ReflectionProvider.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/converters/reflection/Sun14ReflectionProvider.java	2010-10-09 18:20:48.000000000 +0100
@@ -22,6 +22,8 @@ import java.util.Collections;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import com.thoughtworks.xstream.core.util.ConcurrentWeakHashMap;
+
 /**
  * Instantiates a new object on the Sun JVM by bypassing the constructor (meaning code in the constructor
  * will never be executed and parameters do not have to be known). This is the same method used by the internals of
@@ -58,7 +60,7 @@ public class Sun14ReflectionProvider ext
     }
 
     private transient ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
-    private transient Map constructorCache = Collections.synchronizedMap(new WeakHashMap());
+    private transient Map constructorCache = new ConcurrentWeakHashMap();
 
     public Sun14ReflectionProvider() {
     	super();
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/DefaultConverterLookup.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/DefaultConverterLookup.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/DefaultConverterLookup.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/DefaultConverterLookup.java	2010-10-09 18:20:48.000000000 +0100
@@ -16,6 +16,7 @@ import com.thoughtworks.xstream.converte
 import com.thoughtworks.xstream.converters.Converter;
 import com.thoughtworks.xstream.converters.ConverterLookup;
 import com.thoughtworks.xstream.converters.ConverterRegistry;
+import com.thoughtworks.xstream.converters.basic.NullConverter;
 import com.thoughtworks.xstream.core.util.PrioritizedList;
 import com.thoughtworks.xstream.mapper.Mapper;
 
@@ -23,6 +24,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * The default implementation of converters lookup.
@@ -34,7 +36,7 @@ import java.util.Map;
 public class DefaultConverterLookup implements ConverterLookup, ConverterRegistry {
 
     private final PrioritizedList converters = new PrioritizedList();
-    private transient Map typeToConverterMap = Collections.synchronizedMap(new HashMap());
+    private transient Map typeToConverterMap = new ConcurrentHashMap();
 
     public DefaultConverterLookup() {
     }
@@ -52,6 +54,7 @@ public class DefaultConverterLookup impl
     }
 
     public Converter lookupConverterForType(Class type) {
+        if(type==null) return NULL;
         Converter cachedConverter = (Converter) typeToConverterMap.get(type);
         if (cachedConverter != null) return cachedConverter;
         Iterator iterator = converters.iterator();
@@ -76,8 +79,9 @@ public class DefaultConverterLookup impl
     }
     
     private Object readResolve() {
-        typeToConverterMap = Collections.synchronizedMap(new HashMap());
+        typeToConverterMap = new ConcurrentHashMap();
         return this;
     }
 
+    private static final NullConverter NULL = new NullConverter();
 }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/JVM.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/JVM.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/JVM.java	2008-12-06 15:47:52.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/JVM.java	2010-10-09 18:20:48.000000000 +0100
@@ -130,6 +130,10 @@ public class JVM {
         return false;
     }
     
+    private static boolean isOracle() {
+        return vendor.indexOf("Oracle") != -1;
+    }
+    
     private static boolean isHitachi() {
         return vendor.indexOf("Hitachi") != -1;
     }
@@ -188,6 +192,7 @@ public class JVM {
             || isIBM()
             || isBlackdown()
             || isBEAWithUnsafeSupport()
+            || isOracle()
             || isHitachi()
             || isSAP() 
             || isDiablo())
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/util/ConcurrentWeakHashMap.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/util/ConcurrentWeakHashMap.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/core/util/ConcurrentWeakHashMap.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/core/util/ConcurrentWeakHashMap.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,1450 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+package com.thoughtworks.xstream.core.util;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * A hash table with <em>weak keys</em>, full concurrency of retrievals, and
+ * adjustable expected concurrency for updates. Similar to
+ * {@link java.util.WeakHashMap}, entries of this table are periodically
+ * removed once their corresponding keys are no longer referenced outside of
+ * this table. In other words, this table will not prevent a key from being
+ * discarded by the garbage collector. Once a key has been discarded by the
+ * collector, the corresponding entry is no longer visible to this table;
+ * however, the entry may occupy space until a future table operation decides to
+ * reclaim it. For this reason, summary functions such as <tt>size</tt> and
+ * <tt>isEmpty</tt> might return a value greater than the observed number of
+ * entries. In order to support a high level of concurrency, stale entries are
+ * only reclaimed during blocking (usually mutating) operations.
+ *
+ * While keys in this table are only held using a weak reference, values are
+ * held using a normal strong reference. This provides the guarantee that a
+ * value will always have at least the same life-span as it's key. For this
+ * reason, care should be taken to ensure that a value never refers, either
+ * directly or indirectly, to its key, thereby preventing reclamation. If weak
+ * values are desired, one can simply use a {@link WeakReference} for the value
+ * type.
+ *
+ * Just like {@link java.util.ConcurrentHashMap}, this class obeys the same
+ * functional specification as {@link java.util.Hashtable}, and includes
+ * versions of methods corresponding to each method of <tt>Hashtable</tt>.
+ * However, even though all operations are thread-safe, retrieval operations do
+ * <em>not</em> entail locking, and there is <em>not</em> any support for
+ * locking the entire table in a way that prevents all access. This class is
+ * fully interoperable with <tt>Hashtable</tt> in programs that rely on its
+ * thread safety but not on its synchronization details.
+ *
+ * <p>
+ * Retrieval operations (including <tt>get</tt>) generally do not block, so
+ * may overlap with update operations (including <tt>put</tt> and
+ * <tt>remove</tt>). Retrievals reflect the results of the most recently
+ * <em>completed</em> update operations holding upon their onset. For
+ * aggregate operations such as <tt>putAll</tt> and <tt>clear</tt>,
+ * concurrent retrievals may reflect insertion or removal of only some entries.
+ * Similarly, Iterators and Enumerations return elements reflecting the state of
+ * the hash table at some point at or since the creation of the
+ * iterator/enumeration. They do <em>not</em> throw
+ * {@link ConcurrentModificationException}. However, iterators are designed to
+ * be used by only one thread at a time.
+ *
+ * <p>
+ * The allowed concurrency among update operations is guided by the optional
+ * <tt>concurrencyLevel</tt> constructor argument (default <tt>16</tt>),
+ * which is used as a hint for internal sizing. The table is internally
+ * partitioned to try to permit the indicated number of concurrent updates
+ * without contention. Because placement in hash tables is essentially random,
+ * the actual concurrency will vary. Ideally, you should choose a value to
+ * accommodate as many threads as will ever concurrently modify the table. Using
+ * a significantly higher value than you need can waste space and time, and a
+ * significantly lower value can lead to thread contention. But overestimates
+ * and underestimates within an order of magnitude do not usually have much
+ * noticeable impact. A value of one is appropriate when it is known that only
+ * one thread will modify and all others will only read. Also, resizing this or
+ * any other kind of hash table is a relatively slow operation, so, when
+ * possible, it is a good idea to provide estimates of expected table sizes in
+ * constructors.
+ *
+ * <p>
+ * This class and its views and iterators implement all of the <em>optional</em>
+ * methods of the {@link Map} and {@link Iterator} interfaces.
+ *
+ * <p>
+ * Like {@link Hashtable} but unlike {@link HashMap}, this class does
+ * <em>not</em> allow <tt>null</tt> to be used as a key or value.
+ *
+ * <p>
+ * This class is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ * Java Collections Framework</a>.
+ *
+ * @author Doug Lea
+ * @author Jason T. Greene
+ * @param <K> the type of keys maintained by this map
+ * @param <V> the type of mapped values
+ */
+public class ConcurrentWeakHashMap<K, V> extends AbstractMap<K, V>
+        implements java.util.concurrent.ConcurrentMap<K, V>, Serializable {
+    private static final long serialVersionUID = 7249069246763182397L;
+
+    /*
+     * The basic strategy is to subdivide the table among Segments,
+     * each of which itself is a concurrently readable hash table.
+     */
+
+    /* ---------------- Constants -------------- */
+
+    /**
+     * The default initial capacity for this table,
+     * used when not otherwise specified in a constructor.
+     */
+    static final int DEFAULT_INITIAL_CAPACITY = 16;
+
+    /**
+     * The default load factor for this table, used when not
+     * otherwise specified in a constructor.
+     */
+    static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+    /**
+     * The default concurrency level for this table, used when not
+     * otherwise specified in a constructor.
+     */
+    static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+
+    /**
+     * The maximum capacity, used if a higher value is implicitly
+     * specified by either of the constructors with arguments.  MUST
+     * be a power of two <= 1<<30 to ensure that entries are indexable
+     * using ints.
+     */
+    static final int MAXIMUM_CAPACITY = 1 << 30;
+
+    /**
+     * The maximum number of segments to allow; used to bound
+     * constructor arguments.
+     */
+    static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
+
+    /**
+     * Number of unsynchronized retries in size and containsValue
+     * methods before resorting to locking. This is used to avoid
+     * unbounded retries if tables undergo continuous modification
+     * which would make it impossible to obtain an accurate result.
+     */
+    static final int RETRIES_BEFORE_LOCK = 2;
+
+    /* ---------------- Fields -------------- */
+
+    /**
+     * Mask value for indexing into segments. The upper bits of a
+     * key's hash code are used to choose the segment.
+     */
+    final int segmentMask;
+
+    /**
+     * Shift value for indexing within segments.
+     */
+    final int segmentShift;
+
+    /**
+     * The segments, each of which is a specialized hash table
+     */
+    final Segment<K,V>[] segments;
+
+    transient Set<K> keySet;
+    transient Set<Map.Entry<K,V>> entrySet;
+    transient Collection<V> values;
+
+    /* ---------------- Small Utilities -------------- */
+
+    /**
+     * Applies a supplemental hash function to a given hashCode, which
+     * defends against poor quality hash functions.  This is critical
+     * because ConcurrentWeakHashMap uses power-of-two length hash tables,
+     * that otherwise encounter collisions for hashCodes that do not
+     * differ in lower or upper bits.
+     */
+    private static int hash(int h) {
+        // Spread bits to regularize both segment and index locations,
+        // using variant of single-word Wang/Jenkins hash.
+        h += (h <<  15) ^ 0xffffcd7d;
+        h ^= (h >>> 10);
+        h += (h <<   3);
+        h ^= (h >>>  6);
+        h += (h <<   2) + (h << 14);
+        return h ^ (h >>> 16);
+    }
+
+    /**
+     * Returns the segment that should be used for key with given hash
+     * @param hash the hash code for the key
+     * @return the segment
+     */
+    final Segment<K,V> segmentFor(int hash) {
+        return segments[(hash >>> segmentShift) & segmentMask];
+    }
+
+    /* ---------------- Inner Classes -------------- */
+
+    /**
+     * A weak-key reference which stores the key hash needed for reclamation.
+     */
+    static final class WeakKeyReference<K> extends WeakReference<K> {
+        final int hash;
+        WeakKeyReference(K key, int hash, ReferenceQueue<K> refQueue) {
+            super(key, refQueue);
+            this.hash = hash;
+        }
+    }
+
+    /**
+     * ConcurrentWeakHashMap list entry. Note that this is never exported
+     * out as a user-visible Map.Entry.
+     *
+     * Because the value field is volatile, not final, it is legal wrt
+     * the Java Memory Model for an unsynchronized reader to see null
+     * instead of initial value when read via a data race.  Although a
+     * reordering leading to this is not likely to ever actually
+     * occur, the Segment.readValueUnderLock method is used as a
+     * backup in case a null (pre-initialized) value is ever seen in
+     * an unsynchronized access method.
+     */
+    static final class HashEntry<K,V> {
+        final WeakReference<K> keyRef;
+        final int hash;
+        volatile V value;
+        final HashEntry<K,V> next;
+
+        HashEntry(K key, int hash, HashEntry<K,V> next, V value, ReferenceQueue<K> refQueue) {
+            this.keyRef = new WeakKeyReference<K>(key, hash, refQueue);
+            this.hash = hash;
+            this.next = next;
+            this.value = value;
+        }
+
+        @SuppressWarnings("unchecked")
+        static final <K,V> HashEntry<K,V>[] newArray(int i) {
+            return new HashEntry[i];
+        }
+    }
+
+    /**
+     * Segments are specialized versions of hash tables.  This
+     * subclasses from ReentrantLock opportunistically, just to
+     * simplify some locking and avoid separate construction.
+     */
+    static final class Segment<K,V> extends ReentrantLock implements Serializable {
+        /*
+         * Segments maintain a table of entry lists that are ALWAYS
+         * kept in a consistent state, so can be read without locking.
+         * Next fields of nodes are immutable (final).  All list
+         * additions are performed at the front of each bin. This
+         * makes it easy to check changes, and also fast to traverse.
+         * When nodes would otherwise be changed, new nodes are
+         * created to replace them. This works well for hash tables
+         * since the bin lists tend to be short. (The average length
+         * is less than two for the default load factor threshold.)
+         *
+         * Read operations can thus proceed without locking, but rely
+         * on selected uses of volatiles to ensure that completed
+         * write operations performed by other threads are
+         * noticed. For most purposes, the "count" field, tracking the
+         * number of elements, serves as that volatile variable
+         * ensuring visibility.  This is convenient because this field
+         * needs to be read in many read operations anyway:
+         *
+         *   - All (unsynchronized) read operations must first read the
+         *     "count" field, and should not look at table entries if
+         *     it is 0.
+         *
+         *   - All (synchronized) write operations should write to
+         *     the "count" field after structurally changing any bin.
+         *     The operations must not take any action that could even
+         *     momentarily cause a concurrent read operation to see
+         *     inconsistent data. This is made easier by the nature of
+         *     the read operations in Map. For example, no operation
+         *     can reveal that the table has grown but the threshold
+         *     has not yet been updated, so there are no atomicity
+         *     requirements for this with respect to reads.
+         *
+         * As a guide, all critical volatile reads and writes to the
+         * count field are marked in code comments.
+         */
+
+        private static final long serialVersionUID = 2249069246763182397L;
+
+        /**
+         * The number of elements in this segment's region.
+         */
+        transient volatile int count;
+
+        /**
+         * Number of updates that alter the size of the table. This is
+         * used during bulk-read methods to make sure they see a
+         * consistent snapshot: If modCounts change during a traversal
+         * of segments computing size or checking containsValue, then
+         * we might have an inconsistent view of state so (usually)
+         * must retry.
+         */
+        transient int modCount;
+
+        /**
+         * The table is rehashed when its size exceeds this threshold.
+         * (The value of this field is always <tt>(int)(capacity *
+         * loadFactor)</tt>.)
+         */
+        transient int threshold;
+
+        /**
+         * The per-segment table.
+         */
+        transient volatile HashEntry<K,V>[] table;
+
+        /**
+         * The load factor for the hash table.  Even though this value
+         * is same for all segments, it is replicated to avoid needing
+         * links to outer object.
+         * @serial
+         */
+        final float loadFactor;
+
+        /**
+         * The collected weak-key reference queue for this segment.
+         * This should be (re)initialized whenever table is assigned,
+         */
+        transient volatile ReferenceQueue<K> refQueue;
+
+        Segment(int initialCapacity, float lf) {
+            loadFactor = lf;
+            setTable(HashEntry.<K,V>newArray(initialCapacity));
+        }
+
+        @SuppressWarnings("unchecked")
+        static final <K,V> Segment<K,V>[] newArray(int i) {
+            return new Segment[i];
+        }
+
+        /**
+         * Sets table to new HashEntry array.
+         * Call only while holding lock or in constructor.
+         */
+        void setTable(HashEntry<K,V>[] newTable) {
+            threshold = (int)(newTable.length * loadFactor);
+            table = newTable;
+            refQueue = new ReferenceQueue<K>();
+        }
+
+        /**
+         * Returns properly casted first entry of bin for given hash.
+         */
+        HashEntry<K,V> getFirst(int hash) {
+            HashEntry<K,V>[] tab = table;
+            return tab[hash & (tab.length - 1)];
+        }
+
+        /**
+         * Reads value field of an entry under lock. Called if value
+         * field ever appears to be null. This is possible only if a
+         * compiler happens to reorder a HashEntry initialization with
+         * its table assignment, which is legal under memory model
+         * but is not known to ever occur.
+         */
+        V readValueUnderLock(HashEntry<K,V> e) {
+            lock();
+            try {
+                removeStale();
+                return e.value;
+            } finally {
+                unlock();
+            }
+        }
+
+        /* Specialized implementations of map methods */
+
+        V get(Object key, int hash) {
+            if (count != 0) { // read-volatile
+                HashEntry<K,V> e = getFirst(hash);
+                while (e != null) {
+                    if (e.hash == hash && key.equals(e.keyRef.get())) {
+                        V v = e.value;
+                        if (v != null)
+                            return v;
+                        return readValueUnderLock(e); // recheck
+                    }
+                    e = e.next;
+                }
+            }
+            return null;
+        }
+
+        boolean containsKey(Object key, int hash) {
+            if (count != 0) { // read-volatile
+                HashEntry<K,V> e = getFirst(hash);
+                while (e != null) {
+                    if (e.hash == hash && key.equals(e.keyRef.get()))
+                        return true;
+                    e = e.next;
+                }
+            }
+            return false;
+        }
+
+        boolean containsValue(Object value) {
+            if (count != 0) { // read-volatile
+                HashEntry<K,V>[] tab = table;
+                int len = tab.length;
+                for (int i = 0 ; i < len; i++) {
+                    for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) {
+                        V v = e.value;
+                        if (v == null) // recheck
+                            v = readValueUnderLock(e);
+                        if (value.equals(v))
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        boolean replace(K key, int hash, V oldValue, V newValue) {
+            lock();
+            try {
+                removeStale();
+                HashEntry<K,V> e = getFirst(hash);
+                while (e != null && (e.hash != hash || !key.equals(e.keyRef.get())))
+                    e = e.next;
+
+                boolean replaced = false;
+                if (e != null && oldValue.equals(e.value)) {
+                    replaced = true;
+                    e.value = newValue;
+                }
+                return replaced;
+            } finally {
+                unlock();
+            }
+        }
+
+        V replace(K key, int hash, V newValue) {
+            lock();
+            try {
+                removeStale();
+                HashEntry<K,V> e = getFirst(hash);
+                while (e != null && (e.hash != hash || !key.equals(e.keyRef.get())))
+                    e = e.next;
+
+                V oldValue = null;
+                if (e != null) {
+                    oldValue = e.value;
+                    e.value = newValue;
+                }
+                return oldValue;
+            } finally {
+                unlock();
+            }
+        }
+
+
+        V put(K key, int hash, V value, boolean onlyIfAbsent) {
+            lock();
+            try {
+                removeStale();
+                int c = count;
+                if (c++ > threshold) {// ensure capacity
+                    int reduced = rehash();
+                    if (reduced > 0)  // adjust from possible weak cleanups
+                        count = (c -= reduced) - 1; // write-volatile
+                }
+
+                HashEntry<K,V>[] tab = table;
+                int index = hash & (tab.length - 1);
+                HashEntry<K,V> first = tab[index];
+                HashEntry<K,V> e = first;
+                while (e != null && (e.hash != hash || !key.equals(e.keyRef.get())))
+                    e = e.next;
+
+                V oldValue;
+                if (e != null) {
+                    oldValue = e.value;
+                    if (!onlyIfAbsent)
+                        e.value = value;
+                }
+                else {
+                    oldValue = null;
+                    ++modCount;
+                    tab[index] = new HashEntry<K,V>(key, hash, first, value, refQueue);
+                    count = c; // write-volatile
+                }
+                return oldValue;
+            } finally {
+                unlock();
+            }
+        }
+
+        int rehash() {
+            HashEntry<K,V>[] oldTable = table;
+            int oldCapacity = oldTable.length;
+            if (oldCapacity >= MAXIMUM_CAPACITY)
+                return 0;
+
+            /*
+             * Reclassify nodes in each list to new Map.  Because we are
+             * using power-of-two expansion, the elements from each bin
+             * must either stay at same index, or move with a power of two
+             * offset. We eliminate unnecessary node creation by catching
+             * cases where old nodes can be reused because their next
+             * fields won't change. Statistically, at the default
+             * threshold, only about one-sixth of them need cloning when
+             * a table doubles. The nodes they replace will be garbage
+             * collectable as soon as they are no longer referenced by any
+             * reader thread that may be in the midst of traversing table
+             * right now.
+             */
+
+            HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);
+            threshold = (int)(newTable.length * loadFactor);
+            int sizeMask = newTable.length - 1;
+            int reduce = 0;
+            for (int i = 0; i < oldCapacity ; i++) {
+                // We need to guarantee that any existing reads of old Map can
+                //  proceed. So we cannot yet null out each bin.
+                HashEntry<K,V> e = oldTable[i];
+
+                if (e != null) {
+                    HashEntry<K,V> next = e.next;
+                    int idx = e.hash & sizeMask;
+
+                    //  Single node on list
+                    if (next == null)
+                        newTable[idx] = e;
+
+                    else {
+                        // Reuse trailing consecutive sequence at same slot
+                        HashEntry<K,V> lastRun = e;
+                        int lastIdx = idx;
+                        for (HashEntry<K,V> last = next;
+                             last != null;
+                             last = last.next) {
+                            int k = last.hash & sizeMask;
+                            if (k != lastIdx) {
+                                lastIdx = k;
+                                lastRun = last;
+                            }
+                        }
+                        newTable[lastIdx] = lastRun;
+                        // Clone all remaining nodes
+                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
+                            // Skip GC'd weak refs
+                            K key = p.keyRef.get();
+                            if (key == null) {
+                                reduce++;
+                                continue;
+                            }
+                            int k = p.hash & sizeMask;
+                            HashEntry<K,V> n = newTable[k];
+                            newTable[k] = new HashEntry<K,V>(key, p.hash, n, p.value, refQueue);
+                        }
+                    }
+                }
+            }
+            table = newTable;
+            return reduce;
+        }
+
+        /**
+         * Remove; match on key only if value null, else match both.
+         */
+        V remove(Object key, int hash, Object value, boolean weakRemove) {
+            lock();
+            try {
+                if (!weakRemove)
+                    removeStale();
+                int c = count - 1;
+                HashEntry<K,V>[] tab = table;
+                int index = hash & (tab.length - 1);
+                HashEntry<K,V> first = tab[index];
+                HashEntry<K,V> e = first;
+                // a weak remove operation compares the WeakReference instance
+                while (e != null && (!weakRemove || key != e.keyRef)
+                                 && (e.hash != hash || !key.equals(e.keyRef.get())))
+                    e = e.next;
+
+                V oldValue = null;
+                if (e != null) {
+                    V v = e.value;
+                    if (value == null || value.equals(v)) {
+                        oldValue = v;
+                        // All entries following removed node can stay
+                        // in list, but all preceding ones need to be
+                        // cloned.
+                        ++modCount;
+                        HashEntry<K,V> newFirst = e.next;
+                        for (HashEntry<K,V> p = first; p != e; p = p.next) {
+                            K pKey = p.keyRef.get();
+                            if (pKey == null) { // Skip GC'd keys
+                                c--;
+                                continue;
+                            }
+
+                            newFirst = new HashEntry<K,V>(pKey, p.hash,
+                                                          newFirst, p.value, refQueue);
+                        }
+                        tab[index] = newFirst;
+                        count = c; // write-volatile
+                    }
+                }
+                return oldValue;
+            } finally {
+                unlock();
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        void removeStale() {
+            WeakKeyReference<K> ref;
+            while ((ref = (WeakKeyReference<K>) refQueue.poll()) != null) {
+                remove(ref, ref.hash, null, true);
+            }
+        }
+
+        void clear() {
+            if (count != 0) {
+                lock();
+                try {
+                    HashEntry<K,V>[] tab = table;
+                    for (int i = 0; i < tab.length ; i++)
+                        tab[i] = null;
+                    ++modCount;
+                    // replace the reference queue to avoid unnecessary stale cleanups
+                    refQueue = new ReferenceQueue<K>();
+                    count = 0; // write-volatile
+                } finally {
+                    unlock();
+                }
+            }
+        }
+    }
+
+
+
+    /* ---------------- Public operations -------------- */
+
+    /**
+     * Creates a new, empty map with the specified initial
+     * capacity, load factor and concurrency level.
+     *
+     * @param initialCapacity the initial capacity. The implementation
+     * performs internal sizing to accommodate this many elements.
+     * @param loadFactor  the load factor threshold, used to control resizing.
+     * Resizing may be performed when the average number of elements per
+     * bin exceeds this threshold.
+     * @param concurrencyLevel the estimated number of concurrently
+     * updating threads. The implementation performs internal sizing
+     * to try to accommodate this many threads.
+     * @throws IllegalArgumentException if the initial capacity is
+     * negative or the load factor or concurrencyLevel are
+     * nonpositive.
+     */
+    public ConcurrentWeakHashMap(int initialCapacity,
+                             float loadFactor, int concurrencyLevel) {
+        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
+            throw new IllegalArgumentException();
+
+        if (concurrencyLevel > MAX_SEGMENTS)
+            concurrencyLevel = MAX_SEGMENTS;
+
+        // Find power-of-two sizes best matching arguments
+        int sshift = 0;
+        int ssize = 1;
+        while (ssize < concurrencyLevel) {
+            ++sshift;
+            ssize <<= 1;
+        }
+        segmentShift = 32 - sshift;
+        segmentMask = ssize - 1;
+        this.segments = Segment.newArray(ssize);
+
+        if (initialCapacity > MAXIMUM_CAPACITY)
+            initialCapacity = MAXIMUM_CAPACITY;
+        int c = initialCapacity / ssize;
+        if (c * ssize < initialCapacity)
+            ++c;
+        int cap = 1;
+        while (cap < c)
+            cap <<= 1;
+
+        for (int i = 0; i < this.segments.length; ++i)
+            this.segments[i] = new Segment<K,V>(cap, loadFactor);
+    }
+
+    /**
+     * Creates a new, empty map with the specified initial capacity
+     * and load factor and with the default concurrencyLevel (16).
+     *
+     * @param initialCapacity The implementation performs internal
+     * sizing to accommodate this many elements.
+     * @param loadFactor  the load factor threshold, used to control resizing.
+     * Resizing may be performed when the average number of elements per
+     * bin exceeds this threshold.
+     * @throws IllegalArgumentException if the initial capacity of
+     * elements is negative or the load factor is nonpositive
+     *
+     * @since 1.6
+     */
+    public ConcurrentWeakHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
+    }
+
+    /**
+     * Creates a new, empty map with the specified initial capacity,
+     * and with default load factor (0.75) and concurrencyLevel (16).
+     *
+     * @param initialCapacity the initial capacity. The implementation
+     * performs internal sizing to accommodate this many elements.
+     * @throws IllegalArgumentException if the initial capacity of
+     * elements is negative.
+     */
+    public ConcurrentWeakHashMap(int initialCapacity) {
+        this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
+    }
+
+    /**
+     * Creates a new, empty map with a default initial capacity (16),
+     * load factor (0.75) and concurrencyLevel (16).
+     */
+    public ConcurrentWeakHashMap() {
+        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
+    }
+
+    /**
+     * Creates a new map with the same mappings as the given map.
+     * The map is created with a capacity of 1.5 times the number
+     * of mappings in the given map or 16 (whichever is greater),
+     * and a default load factor (0.75) and concurrencyLevel (16).
+     *
+     * @param m the map
+     */
+    public ConcurrentWeakHashMap(Map<? extends K, ? extends V> m) {
+        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
+                      DEFAULT_INITIAL_CAPACITY),
+             DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
+        putAll(m);
+    }
+
+    /**
+     * Returns <tt>true</tt> if this map contains no key-value mappings.
+     *
+     * @return <tt>true</tt> if this map contains no key-value mappings
+     */
+    public boolean isEmpty() {
+        final Segment<K,V>[] segments = this.segments;
+        /*
+         * We keep track of per-segment modCounts to avoid ABA
+         * problems in which an element in one segment was added and
+         * in another removed during traversal, in which case the
+         * table was never actually empty at any point. Note the
+         * similar use of modCounts in the size() and containsValue()
+         * methods, which are the only other methods also susceptible
+         * to ABA problems.
+         */
+        int[] mc = new int[segments.length];
+        int mcsum = 0;
+        for (int i = 0; i < segments.length; ++i) {
+            if (segments[i].count != 0)
+                return false;
+            else
+                mcsum += mc[i] = segments[i].modCount;
+        }
+        // If mcsum happens to be zero, then we know we got a snapshot
+        // before any modifications at all were made.  This is
+        // probably common enough to bother tracking.
+        if (mcsum != 0) {
+            for (int i = 0; i < segments.length; ++i) {
+                if (segments[i].count != 0 ||
+                    mc[i] != segments[i].modCount)
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns the number of key-value mappings in this map.  If the
+     * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
+     * <tt>Integer.MAX_VALUE</tt>.
+     *
+     * @return the number of key-value mappings in this map
+     */
+    public int size() {
+        final Segment<K,V>[] segments = this.segments;
+        long sum = 0;
+        long check = 0;
+        int[] mc = new int[segments.length];
+        // Try a few times to get accurate count. On failure due to
+        // continuous async changes in table, resort to locking.
+        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
+            check = 0;
+            sum = 0;
+            int mcsum = 0;
+            for (int i = 0; i < segments.length; ++i) {
+                sum += segments[i].count;
+                mcsum += mc[i] = segments[i].modCount;
+            }
+            if (mcsum != 0) {
+                for (int i = 0; i < segments.length; ++i) {
+                    check += segments[i].count;
+                    if (mc[i] != segments[i].modCount) {
+                        check = -1; // force retry
+                        break;
+                    }
+                }
+            }
+            if (check == sum)
+                break;
+        }
+        if (check != sum) { // Resort to locking all segments
+            sum = 0;
+            for (int i = 0; i < segments.length; ++i)
+                segments[i].lock();
+            for (int i = 0; i < segments.length; ++i)
+                sum += segments[i].count;
+            for (int i = 0; i < segments.length; ++i)
+                segments[i].unlock();
+        }
+        if (sum > Integer.MAX_VALUE)
+            return Integer.MAX_VALUE;
+        else
+            return (int)sum;
+    }
+
+    /**
+     * Returns the value to which the specified key is mapped,
+     * or {@code null} if this map contains no mapping for the key.
+     *
+     * <p>More formally, if this map contains a mapping from a key
+     * {@code k} to a value {@code v} such that {@code key.equals(k)},
+     * then this method returns {@code v}; otherwise it returns
+     * {@code null}.  (There can be at most one such mapping.)
+     *
+     * @throws NullPointerException if the specified key is null
+     */
+    public V get(Object key) {
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).get(key, hash);
+    }
+
+    /**
+     * Tests if the specified object is a key in this table.
+     *
+     * @param  key   possible key
+     * @return <tt>true</tt> if and only if the specified object
+     *         is a key in this table, as determined by the
+     *         <tt>equals</tt> method; <tt>false</tt> otherwise.
+     * @throws NullPointerException if the specified key is null
+     */
+    public boolean containsKey(Object key) {
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).containsKey(key, hash);
+    }
+
+    /**
+     * Returns <tt>true</tt> if this map maps one or more keys to the
+     * specified value. Note: This method requires a full internal
+     * traversal of the hash table, and so is much slower than
+     * method <tt>containsKey</tt>.
+     *
+     * @param value value whose presence in this map is to be tested
+     * @return <tt>true</tt> if this map maps one or more keys to the
+     *         specified value
+     * @throws NullPointerException if the specified value is null
+     */
+    public boolean containsValue(Object value) {
+        if (value == null)
+            throw new NullPointerException();
+
+        // See explanation of modCount use above
+
+        final Segment<K,V>[] segments = this.segments;
+        int[] mc = new int[segments.length];
+
+        // Try a few times without locking
+        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
+            int sum = 0;
+            int mcsum = 0;
+            for (int i = 0; i < segments.length; ++i) {
+                int c = segments[i].count;
+                mcsum += mc[i] = segments[i].modCount;
+                if (segments[i].containsValue(value))
+                    return true;
+            }
+            boolean cleanSweep = true;
+            if (mcsum != 0) {
+                for (int i = 0; i < segments.length; ++i) {
+                    int c = segments[i].count;
+                    if (mc[i] != segments[i].modCount) {
+                        cleanSweep = false;
+                        break;
+                    }
+                }
+            }
+            if (cleanSweep)
+                return false;
+        }
+        // Resort to locking all segments
+        for (int i = 0; i < segments.length; ++i)
+            segments[i].lock();
+        boolean found = false;
+        try {
+            for (int i = 0; i < segments.length; ++i) {
+                if (segments[i].containsValue(value)) {
+                    found = true;
+                    break;
+                }
+            }
+        } finally {
+            for (int i = 0; i < segments.length; ++i)
+                segments[i].unlock();
+        }
+        return found;
+    }
+
+    /**
+     * Legacy method testing if some key maps into the specified value
+     * in this table.  This method is identical in functionality to
+     * {@link #containsValue}, and exists solely to ensure
+     * full compatibility with class {@link java.util.Hashtable},
+     * which supported this method prior to introduction of the
+     * Java Collections framework.
+
+     * @param  value a value to search for
+     * @return <tt>true</tt> if and only if some key maps to the
+     *         <tt>value</tt> argument in this table as
+     *         determined by the <tt>equals</tt> method;
+     *         <tt>false</tt> otherwise
+     * @throws NullPointerException if the specified value is null
+     */
+    public boolean contains(Object value) {
+        return containsValue(value);
+    }
+
+    /**
+     * Maps the specified key to the specified value in this table.
+     * Neither the key nor the value can be null.
+     *
+     * <p> The value can be retrieved by calling the <tt>get</tt> method
+     * with a key that is equal to the original key.
+     *
+     * @param key key with which the specified value is to be associated
+     * @param value value to be associated with the specified key
+     * @return the previous value associated with <tt>key</tt>, or
+     *         <tt>null</tt> if there was no mapping for <tt>key</tt>
+     * @throws NullPointerException if the specified key or value is null
+     */
+    public V put(K key, V value) {
+        if (value == null)
+            throw new NullPointerException();
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).put(key, hash, value, false);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @return the previous value associated with the specified key,
+     *         or <tt>null</tt> if there was no mapping for the key
+     * @throws NullPointerException if the specified key or value is null
+     */
+    public V putIfAbsent(K key, V value) {
+        if (value == null)
+            throw new NullPointerException();
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).put(key, hash, value, true);
+    }
+
+    /**
+     * Copies all of the mappings from the specified map to this one.
+     * These mappings replace any mappings that this map had for any of the
+     * keys currently in the specified map.
+     *
+     * @param m mappings to be stored in this map
+     */
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
+            put(e.getKey(), e.getValue());
+    }
+
+    /**
+     * Removes the key (and its corresponding value) from this map.
+     * This method does nothing if the key is not in the map.
+     *
+     * @param  key the key that needs to be removed
+     * @return the previous value associated with <tt>key</tt>, or
+     *         <tt>null</tt> if there was no mapping for <tt>key</tt>
+     * @throws NullPointerException if the specified key is null
+     */
+    public V remove(Object key) {
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).remove(key, hash, null, false);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if the specified key is null
+     */
+    public boolean remove(Object key, Object value) {
+        int hash = hash(key.hashCode());
+        if (value == null)
+            return false;
+        return segmentFor(hash).remove(key, hash, value, false) != null;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws NullPointerException if any of the arguments are null
+     */
+    public boolean replace(K key, V oldValue, V newValue) {
+        if (oldValue == null || newValue == null)
+            throw new NullPointerException();
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).replace(key, hash, oldValue, newValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @return the previous value associated with the specified key,
+     *         or <tt>null</tt> if there was no mapping for the key
+     * @throws NullPointerException if the specified key or value is null
+     */
+    public V replace(K key, V value) {
+        if (value == null)
+            throw new NullPointerException();
+        int hash = hash(key.hashCode());
+        return segmentFor(hash).replace(key, hash, value);
+    }
+
+    /**
+     * Removes all of the mappings from this map.
+     */
+    public void clear() {
+        for (int i = 0; i < segments.length; ++i)
+            segments[i].clear();
+    }
+
+    /**
+     * Returns a {@link Set} view of the keys contained in this map.
+     * The set is backed by the map, so changes to the map are
+     * reflected in the set, and vice-versa.  The set supports element
+     * removal, which removes the corresponding mapping from this map,
+     * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
+     * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
+     * operations.  It does not support the <tt>add</tt> or
+     * <tt>addAll</tt> operations.
+     *
+     * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
+     * that will never throw {@link ConcurrentModificationException},
+     * and guarantees to traverse elements as they existed upon
+     * construction of the iterator, and may (but is not guaranteed to)
+     * reflect any modifications subsequent to construction.
+     */
+    public Set<K> keySet() {
+        Set<K> ks = keySet;
+        return (ks != null) ? ks : (keySet = new KeySet());
+    }
+
+    /**
+     * Returns a {@link Collection} view of the values contained in this map.
+     * The collection is backed by the map, so changes to the map are
+     * reflected in the collection, and vice-versa.  The collection
+     * supports element removal, which removes the corresponding
+     * mapping from this map, via the <tt>Iterator.remove</tt>,
+     * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
+     * <tt>retainAll</tt>, and <tt>clear</tt> operations.  It does not
+     * support the <tt>add</tt> or <tt>addAll</tt> operations.
+     *
+     * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
+     * that will never throw {@link ConcurrentModificationException},
+     * and guarantees to traverse elements as they existed upon
+     * construction of the iterator, and may (but is not guaranteed to)
+     * reflect any modifications subsequent to construction.
+     */
+    public Collection<V> values() {
+        Collection<V> vs = values;
+        return (vs != null) ? vs : (values = new Values());
+    }
+
+    /**
+     * Returns a {@link Set} view of the mappings contained in this map.
+     * The set is backed by the map, so changes to the map are
+     * reflected in the set, and vice-versa.  The set supports element
+     * removal, which removes the corresponding mapping from the map,
+     * via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
+     * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
+     * operations.  It does not support the <tt>add</tt> or
+     * <tt>addAll</tt> operations.
+     *
+     * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
+     * that will never throw {@link ConcurrentModificationException},
+     * and guarantees to traverse elements as they existed upon
+     * construction of the iterator, and may (but is not guaranteed to)
+     * reflect any modifications subsequent to construction.
+     */
+    public Set<Map.Entry<K,V>> entrySet() {
+        Set<Map.Entry<K,V>> es = entrySet;
+        return (es != null) ? es : (entrySet = new EntrySet());
+    }
+
+    /**
+     * Returns an enumeration of the keys in this table.
+     *
+     * @return an enumeration of the keys in this table
+     * @see #keySet()
+     */
+    public Enumeration<K> keys() {
+        return new KeyIterator();
+    }
+
+    /**
+     * Returns an enumeration of the values in this table.
+     *
+     * @return an enumeration of the values in this table
+     * @see #values()
+     */
+    public Enumeration<V> elements() {
+        return new ValueIterator();
+    }
+
+    /* ---------------- Iterator Support -------------- */
+
+    abstract class HashIterator {
+        int nextSegmentIndex;
+        int nextTableIndex;
+        HashEntry<K,V>[] currentTable;
+        HashEntry<K, V> nextEntry;
+        HashEntry<K, V> lastReturned;
+        K currentKey; // Strong reference to weak key (prevents gc)
+
+        HashIterator() {
+            nextSegmentIndex = segments.length - 1;
+            nextTableIndex = -1;
+            advance();
+        }
+
+        public boolean hasMoreElements() { return hasNext(); }
+
+        final void advance() {
+            if (nextEntry != null && (nextEntry = nextEntry.next) != null)
+                return;
+
+            while (nextTableIndex >= 0) {
+                if ( (nextEntry = currentTable[nextTableIndex--]) != null)
+                    return;
+            }
+
+            while (nextSegmentIndex >= 0) {
+                Segment<K,V> seg = segments[nextSegmentIndex--];
+                if (seg.count != 0) {
+                    currentTable = seg.table;
+                    for (int j = currentTable.length - 1; j >= 0; --j) {
+                        if ( (nextEntry = currentTable[j]) != null) {
+                            nextTableIndex = j - 1;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        public boolean hasNext() {
+            while (nextEntry != null) {
+                if (nextEntry.keyRef.get() != null)
+                    return true;
+                advance();
+            }
+
+            return false;
+        }
+
+        HashEntry<K,V> nextEntry() {
+            do {
+                if (nextEntry == null)
+                    throw new NoSuchElementException();
+
+                lastReturned = nextEntry;
+                currentKey = lastReturned.keyRef.get();
+                advance();
+            } while (currentKey == null); // Skip GC'd keys
+
+            return lastReturned;
+        }
+
+        public void remove() {
+            if (lastReturned == null)
+                throw new IllegalStateException();
+            ConcurrentWeakHashMap.this.remove(currentKey);
+            lastReturned = null;
+        }
+    }
+
+    final class KeyIterator
+        extends HashIterator
+        implements Iterator<K>, Enumeration<K>
+    {
+        public K next()        { return super.nextEntry().keyRef.get(); }
+        public K nextElement() { return super.nextEntry().keyRef.get(); }
+    }
+
+    final class ValueIterator
+        extends HashIterator
+        implements Iterator<V>, Enumeration<V>
+    {
+        public V next()        { return super.nextEntry().value; }
+        public V nextElement() { return super.nextEntry().value; }
+    }
+
+     /*
+      * This class is needed for JDK5 compatibility.
+      */
+     static class SimpleEntry<K, V> implements Entry<K, V>,
+            java.io.Serializable {
+        private static final long serialVersionUID = -8499721149061103585L;
+
+        private final K key;
+        private V value;
+
+        public SimpleEntry(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public SimpleEntry(Entry<? extends K, ? extends V> entry) {
+            this.key = entry.getKey();
+            this.value = entry.getValue();
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public V setValue(V value) {
+            V oldValue = this.value;
+            this.value = value;
+            return oldValue;
+        }
+
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            @SuppressWarnings("unchecked")
+            Map.Entry e = (Map.Entry) o;
+            return eq(key, e.getKey()) && eq(value, e.getValue());
+        }
+
+        public int hashCode() {
+            return (key == null ? 0 : key.hashCode())
+                    ^ (value == null ? 0 : value.hashCode());
+        }
+
+        public String toString() {
+            return key + "=" + value;
+        }
+
+        private static boolean eq(Object o1, Object o2) {
+            return o1 == null ? o2 == null : o1.equals(o2);
+        }
+    }
+
+
+    /**
+     * Custom Entry class used by EntryIterator.next(), that relays setValue
+     * changes to the underlying map.
+     */
+    final class WriteThroughEntry extends SimpleEntry<K,V>
+    {
+        private static final long serialVersionUID = -7900634345345313646L;
+
+        WriteThroughEntry(K k, V v) {
+            super(k,v);
+        }
+
+        /**
+         * Set our entry's value and write through to the map. The
+         * value to return is somewhat arbitrary here. Since a
+         * WriteThroughEntry does not necessarily track asynchronous
+         * changes, the most recent "previous" value could be
+         * different from what we return (or could even have been
+         * removed in which case the put will re-establish). We do not
+         * and cannot guarantee more.
+         */
+        public V setValue(V value) {
+            if (value == null) throw new NullPointerException();
+            V v = super.setValue(value);
+            ConcurrentWeakHashMap.this.put(getKey(), value);
+            return v;
+        }
+    }
+
+    final class EntryIterator
+        extends HashIterator
+        implements Iterator<Entry<K,V>>
+    {
+        public Map.Entry<K,V> next() {
+            HashEntry<K,V> e = super.nextEntry();
+            return new WriteThroughEntry(e.keyRef.get(), e.value);
+        }
+    }
+
+    final class KeySet extends AbstractSet<K> {
+        public Iterator<K> iterator() {
+            return new KeyIterator();
+        }
+        public int size() {
+            return ConcurrentWeakHashMap.this.size();
+        }
+        public boolean isEmpty() {
+            return ConcurrentWeakHashMap.this.isEmpty();
+        }
+        public boolean contains(Object o) {
+            return ConcurrentWeakHashMap.this.containsKey(o);
+        }
+        public boolean remove(Object o) {
+            return ConcurrentWeakHashMap.this.remove(o) != null;
+        }
+        public void clear() {
+            ConcurrentWeakHashMap.this.clear();
+        }
+    }
+
+    final class Values extends AbstractCollection<V> {
+        public Iterator<V> iterator() {
+            return new ValueIterator();
+        }
+        public int size() {
+            return ConcurrentWeakHashMap.this.size();
+        }
+        public boolean isEmpty() {
+            return ConcurrentWeakHashMap.this.isEmpty();
+        }
+        public boolean contains(Object o) {
+            return ConcurrentWeakHashMap.this.containsValue(o);
+        }
+        public void clear() {
+            ConcurrentWeakHashMap.this.clear();
+        }
+    }
+
+    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
+        public Iterator<Map.Entry<K,V>> iterator() {
+            return new EntryIterator();
+        }
+        public boolean contains(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
+            V v = ConcurrentWeakHashMap.this.get(e.getKey());
+            return v != null && v.equals(e.getValue());
+        }
+        public boolean remove(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
+            return ConcurrentWeakHashMap.this.remove(e.getKey(), e.getValue());
+        }
+        public int size() {
+            return ConcurrentWeakHashMap.this.size();
+        }
+        public boolean isEmpty() {
+            return ConcurrentWeakHashMap.this.isEmpty();
+        }
+        public void clear() {
+            ConcurrentWeakHashMap.this.clear();
+        }
+    }
+
+    /* ---------------- Serialization Support -------------- */
+
+    /**
+     * Save the state of the <tt>ConcurrentWeakHashMap</tt> instance to a
+     * stream (i.e., serialize it).
+     * @param s the stream
+     * @serialData
+     * the key (Object) and value (Object)
+     * for each key-value mapping, followed by a null pair.
+     * The key-value mappings are emitted in no particular order.
+     */
+    private void writeObject(java.io.ObjectOutputStream s) throws IOException  {
+        s.defaultWriteObject();
+
+        for (int k = 0; k < segments.length; ++k) {
+            Segment<K,V> seg = segments[k];
+            seg.lock();
+            try {
+                HashEntry<K,V>[] tab = seg.table;
+                for (int i = 0; i < tab.length; ++i) {
+                    for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) {
+                        K key = e.keyRef.get();
+                        if (key == null) // Skip GC'd keys
+                            continue;
+
+                        s.writeObject(key);
+                        s.writeObject(e.value);
+                    }
+                }
+            } finally {
+                seg.unlock();
+            }
+        }
+        s.writeObject(null);
+        s.writeObject(null);
+    }
+
+    /**
+     * Reconstitute the <tt>ConcurrentWeakHashMap</tt> instance from a
+     * stream (i.e., deserialize it).
+     * @param s the stream
+     */
+    @SuppressWarnings("unchecked")
+    private void readObject(java.io.ObjectInputStream s)
+        throws IOException, ClassNotFoundException  {
+        s.defaultReadObject();
+
+        // Initialize each segment to be minimally sized, and let grow.
+        for (int i = 0; i < segments.length; ++i) {
+            segments[i].setTable(new HashEntry[1]);
+        }
+
+        // Read the keys and values, and put the mappings in the table
+        for (;;) {
+            K key = (K) s.readObject();
+            V value = (V) s.readObject();
+            if (key == null)
+                break;
+            put(key, value);
+        }
+    }
+}
\ No newline at end of file
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/HierarchicalStreamReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/HierarchicalStreamReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/HierarchicalStreamReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/HierarchicalStreamReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -26,6 +26,12 @@ public interface HierarchicalStreamReade
     boolean hasMoreChildren();
 
     /**
+     * In situation where {@link #hasMoreChildren()} returns true, peek the tag name
+     * of the child.
+     */
+    String peekNextChild();
+
+    /**
      * Select the current child as current node.
      * A call to this function must be balanced with a call to {@link #moveUp()}.
      */
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/ReaderWrapper.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/ReaderWrapper.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/ReaderWrapper.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/ReaderWrapper.java	2010-10-09 18:20:48.000000000 +0100
@@ -32,6 +32,10 @@ public abstract class ReaderWrapper impl
         return wrapped.hasMoreChildren();
     }
 
+    public String peekNextChild() {
+        return wrapped.peekNextChild();
+    }
+
     public void moveDown() {
         wrapped.moveDown();
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/binary/BinaryStreamReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/binary/BinaryStreamReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/binary/BinaryStreamReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/binary/BinaryStreamReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -50,6 +50,21 @@ public class BinaryStreamReader implemen
         return depthState.hasMoreChildren();
     }
 
+    public String peekNextChild() {
+        Token nextToken = readToken();
+        switch (nextToken.getType()) {
+            case Token.TYPE_VALUE:
+            case Token.TYPE_END_NODE:
+                pushBack(nextToken);
+                return null;
+            case Token.TYPE_START_NODE:
+                pushBack(nextToken);
+                return idRegistry.get(nextToken.getId());
+            default:
+                throw new StreamException("Unexpected token " + nextToken);
+        }
+    }
+
     public String getNodeName() {
         return depthState.getName();
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/AbstractPullReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/AbstractPullReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/AbstractPullReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/AbstractPullReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -88,6 +88,23 @@ public abstract class AbstractPullReader
         }
     }
 
+    public String peekNextChild() {
+        mark();
+        while (true) {
+            Event ev = readEvent();
+            switch (ev.type) {
+                case START_NODE:
+                    reset();
+                    return ev.value;
+                case END_NODE:
+                    reset();
+                    return null;
+                default:
+                    continue;
+            }
+        }
+    }
+
     public void moveDown() {
         int currentDepth = elementStack.size();
         while (elementStack.size() <= currentDepth) {
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/Dom4JReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/Dom4JReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/Dom4JReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/Dom4JReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -16,6 +16,8 @@ import com.thoughtworks.xstream.converte
 import org.dom4j.Document;
 import org.dom4j.Element;
 
+import java.util.List;
+
 public class Dom4JReader extends AbstractDocumentReader {
 
     private Element currentElement;
@@ -41,7 +43,13 @@ public class Dom4JReader extends Abstrac
     public Dom4JReader(Document document, XmlFriendlyReplacer replacer) {
         this(document.getRootElement(), replacer);
     }
-    
+
+    public String peekNextChild() {
+        List list = currentElement.elements();
+        if(list.isEmpty())  return null;
+        return unescapeXmlName(((Element)list.get(0)).getName());
+    }
+
     public String getNodeName() {
         return unescapeXmlName(currentElement.getName());
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/DomReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/DomReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/DomReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/DomReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -49,7 +49,19 @@ public class DomReader extends AbstractD
     public DomReader(Document document, XmlFriendlyReplacer replacer) {
         this(document.getDocumentElement(), replacer);
     }
-    
+
+    public String peekNextChild() {
+        NodeList childNodes = currentElement.getChildNodes();
+        childElements = new ArrayList();
+        for (int i = 0; i < childNodes.getLength(); i++) {
+            Node node = childNodes.item(i);
+            if (node instanceof Element) {
+                return unescapeXmlName(((Element)node).getTagName());
+            }
+        }
+        return null;
+    }
+
     public String getNodeName() {
         return unescapeXmlName(currentElement.getTagName());
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/JDomReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/JDomReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/JDomReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/JDomReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -15,6 +15,8 @@ import org.jdom.Attribute;
 import org.jdom.Document;
 import org.jdom.Element;
 
+import java.util.List;
+
 /**
  * @author Laurent Bihanic
  */
@@ -60,6 +62,12 @@ public class JDomReader extends Abstract
         // return currentElement.getParent();
     }
 
+    public String peekNextChild() {
+        List list = currentElement.getChildren();
+        if(list.isEmpty())  return null;
+        return unescapeXmlName(((Element)list.get(0)).getName());
+    }
+
     protected Object getChild(int index) {
         return currentElement.getChildren().get(index);
     }
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XmlFriendlyReplacer.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XmlFriendlyReplacer.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XmlFriendlyReplacer.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XmlFriendlyReplacer.java	2010-10-09 18:20:48.000000000 +0100
@@ -115,6 +115,8 @@ public class XmlFriendlyReplacer {
      * @return The String with unescaped name
      */
     public String unescapeName(String name) {
+        // common path: there's nothing that was escaped
+        if(name.indexOf(underscoreReplacement)<0 && name.indexOf(dollarReplacement)<0)  return name;
         final WeakReference ref = (WeakReference)unescapeCache.get(name);
         String s = (String)(ref == null ? null : ref.get());
 
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XomReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XomReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XomReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XomReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -15,6 +15,7 @@ import nu.xom.Document;
 import nu.xom.Element;
 import nu.xom.Node;
 import nu.xom.Text;
+import nu.xom.Elements;
 
 public class XomReader extends AbstractDocumentReader {
 
@@ -46,6 +47,12 @@ public class XomReader extends AbstractD
         return unescapeXmlName(currentElement.getLocalName());
     }
 
+    public String peekNextChild() {
+        Elements children = currentElement.getChildElements();
+        if(children.size()==0)  return null;
+        return unescapeXmlName(children.get(0).getLocalName());
+    }
+
     public String getValue() {
         // currentElement.getValue() not used as this includes text of child elements, which we don't want.
         StringBuffer result = new StringBuffer();
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XppDomReader.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XppDomReader.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/io/xml/XppDomReader.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/io/xml/XppDomReader.java	2010-10-09 18:20:48.000000000 +0100
@@ -36,6 +36,11 @@ public class XppDomReader extends Abstra
         return unescapeXmlName(currentElement.getName());
     }
 
+    public String peekNextChild() {
+        if(currentElement.getChildCount()==0)   return null;
+        return unescapeXmlName(currentElement.getChild(0).getName());
+    }
+
     public String getValue() {
         String text = null;
 
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/mapper/AnnotationMapper.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/mapper/AnnotationMapper.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/mapper/AnnotationMapper.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/mapper/AnnotationMapper.java	2010-10-09 18:20:48.000000000 +0100
@@ -20,6 +20,7 @@ import com.thoughtworks.xstream.annotati
 import com.thoughtworks.xstream.annotations.XStreamImplicitCollection;
 import com.thoughtworks.xstream.annotations.XStreamInclude;
 import com.thoughtworks.xstream.annotations.XStreamOmitField;
+import com.thoughtworks.xstream.annotations.XStreamSerializeAs;
 import com.thoughtworks.xstream.converters.Converter;
 import com.thoughtworks.xstream.converters.ConverterMatcher;
 import com.thoughtworks.xstream.converters.ConverterRegistry;
@@ -68,6 +69,8 @@ public class AnnotationMapper extends Ma
     private final Map<Class<?>, Converter> converterCache = new HashMap<Class<?>, Converter>();
     private final Set<Class<?>> annotatedTypes = new WeakHashSet<Class<?>>();
 
+    private final Map<Class,String> serializedClass = new WeakHashMap<Class, String>();
+
     /**
      * Construct an AnnotationMapper.
      * 
@@ -104,6 +107,8 @@ public class AnnotationMapper extends Ma
         if (!locked) {
             processAnnotations(type);
         }
+        String name = serializedClass.get(type);
+        if (name!=null) return name;
         return super.serializedClass(type);
     }
 
@@ -150,6 +155,7 @@ public class AnnotationMapper extends Ma
             return;
         }
         synchronized (annotatedTypes) {
+            if (annotatedTypes.contains(initialType))   return;
             final Set<Class<?>> types = new UnprocessedTypesSet();
             types.add(initialType);
             processTypes(types);
@@ -167,6 +173,10 @@ public class AnnotationMapper extends Ma
                     continue;
                 }
 
+                XStreamSerializeAs a = type.getAnnotation(XStreamSerializeAs.class);
+                if (a!=null && a.value()!=void.class)
+                    serializedClass.put(type,a.value().getName());
+
                 addParametrizedTypes(type, types);
 
                 processConverterAnnotations(type);
diff -u -rupN xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java
--- xstream-1.3.1//xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java	2008-12-06 15:47:50.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/java/com/thoughtworks/xstream/mapper/CachingMapper.java	2010-10-09 18:20:48.000000000 +0100
@@ -17,6 +17,7 @@ import java.lang.ref.WeakReference;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Mapper that caches which names map to which classes. Prevents repetitive searching and class loading.
@@ -43,20 +44,26 @@ public class CachingMapper extends Mappe
     public Class realClass(String elementName) {
         WeakReference reference = (WeakReference) realClassCache.get(elementName);
         if (reference != null) {
-            Class cached = (Class) reference.get();
+            Object cached = reference.get();
+            if (cached instanceof CannotResolveClassException)
+                throw (CannotResolveClassException) cached;
             if (cached != null) {
-                return cached;
+                return (Class)cached;
             }
         }
-        
-        Class result = super.realClass(elementName);
-        realClassCache.put(elementName, new WeakReference(result));
-        return result;
+
+        try {
+            Class result = super.realClass(elementName);
+            realClassCache.put(elementName, new WeakReference(result));
+            return result;
+        } catch (CannotResolveClassException e) {
+            realClassCache.put(elementName,new WeakReference(e));
+            throw e;
+        }
     }
 
     private Object readResolve() {
-        realClassCache = Collections.synchronizedMap(new HashMap(128));
+        realClassCache = new ConcurrentHashMap();
         return this;
     }
-
 }
diff -u -rupN xstream-1.3.1//xstream/src/test/com/thoughtworks/xstream/converters/enums/EnumConverterTest.java jenkins-xstream-1.3.1-hudson-8//xstream/src/test/com/thoughtworks/xstream/converters/enums/EnumConverterTest.java
--- xstream-1.3.1//xstream/src/test/com/thoughtworks/xstream/converters/enums/EnumConverterTest.java	2008-12-06 15:47:48.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/test/com/thoughtworks/xstream/converters/enums/EnumConverterTest.java	2010-10-09 18:20:48.000000000 +0100
@@ -40,6 +40,12 @@ public class EnumConverterTest extends T
         assertEquals(in, xstream.fromXML(expectedXml));
     }
 
+    public void testRelaxedNameMatch() {
+        String expectedXml = "<simple>green</simple>";
+        SimpleEnum in = SimpleEnum.GREEN;
+        assertEquals(in, xstream.fromXML(expectedXml));
+    }
+
     public void testRepresentsPolymorphicEnumAsSingleStringValue() {
         String expectedXml = "<polymorphic>B</polymorphic>";
         PolymorphicEnum in = PolymorphicEnum.B;
diff -u -rupN xstream-1.3.1//xstream/src/test/com/thoughtworks/xstream/core/DefaultConverterLookupTest.java jenkins-xstream-1.3.1-hudson-8//xstream/src/test/com/thoughtworks/xstream/core/DefaultConverterLookupTest.java
--- xstream-1.3.1//xstream/src/test/com/thoughtworks/xstream/core/DefaultConverterLookupTest.java	2008-12-06 15:47:46.000000000 +0000
+++ jenkins-xstream-1.3.1-hudson-8//xstream/src/test/com/thoughtworks/xstream/core/DefaultConverterLookupTest.java	2010-10-09 18:20:48.000000000 +0100
@@ -12,12 +12,15 @@
 package com.thoughtworks.xstream.core;
 
 import java.util.BitSet;
+import java.io.ByteArrayInputStream;
 
 import junit.framework.TestCase;
 
 import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.mapper.CannotResolveClassException;
 import com.thoughtworks.xstream.converters.Converter;
 import com.thoughtworks.xstream.converters.SingleValueConverterWrapper;
+import com.thoughtworks.xstream.converters.ConversionException;
 import com.thoughtworks.xstream.converters.basic.StringConverter;
 import com.thoughtworks.xstream.converters.collections.BitSetConverter;
 
@@ -41,4 +44,25 @@ public class DefaultConverterLookupTest
 		assertEquals(lookup.lookupConverterForType(String.class), newConverter);
 	}
 
+    /**
+     * Caching the failure should function correctly.
+     * 
+     */
+    public void testFailureCache() {
+        String xml = "<root><field class='NoSuchClass'/></root>";
+        XStream xs = new XStream();
+        xs.alias("root",Root.class);
+        for (int i=0; i<3; i++) {
+            try {
+                xs.fromXML(new ByteArrayInputStream(xml.getBytes()));
+                fail(); // should fail to unmarshal
+            } catch (ConversionException e) {
+                assertTrue(e.getCause() instanceof CannotResolveClassException);
+            }
+        }
+    }
+
+    public static class Root {
+        public Object field;
+    }
 }
diff -u -rupN xstream-1.3.1//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field$Reflection.java jenkins-xstream-1.3.1-hudson-8//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field$Reflection.java
--- xstream-1.3.1//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field$Reflection.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field$Reflection.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2007 XStream Committers.
+ * All rights reserved.
+ *
+ * The software in this package is published under the terms of the BSD
+ * style license a copy of which has been included with this distribution in
+ * the LICENSE.txt file.
+ * 
+ * Created on 13. September 2007 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.benchmark.xmlfriendly.target;
+
+import com.thoughtworks.xstream.benchmark.reflection.targets.AbstractReflectionTarget;
+import com.thoughtworks.xstream.benchmark.xmlfriendly.model.A100$Fields;
+import com.thoughtworks.xstream.tools.benchmark.Target;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A Target for a 100 fields class with each field name containing 5 dollars.
+ * 
+ * @author J&ouml;rg Schaible
+ * @see com.thoughtworks.xstream.tools.benchmark.Harness
+ * @see Target
+ */
+public class Field$Reflection extends AbstractReflectionTarget {
+
+    public Field$Reflection() {
+        super(new ArrayList());
+        List list = (List)target();
+        for(int i = 0; i < 100; ++i) {
+            Object o = new A100$Fields();
+            fill(o);
+            list.add(o);
+        }
+    }
+
+    public String toString() {
+        return "Field with dollars Target";
+    }
+
+}
diff -u -rupN xstream-1.3.1//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field_Reflection.java jenkins-xstream-1.3.1-hudson-8//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field_Reflection.java
--- xstream-1.3.1//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field_Reflection.java	1970-01-01 01:00:00.000000000 +0100
+++ jenkins-xstream-1.3.1-hudson-8//xstream-benchmark/src/test/com/thoughtworks/xstream/benchmark/xmlfriendly/target/Field_Reflection.java	2010-10-09 18:20:48.000000000 +0100
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2007 XStream Committers.
+ * All rights reserved.
+ *
+ * The software in this package is published under the terms of the BSD
+ * style license a copy of which has been included with this distribution in
+ * the LICENSE.txt file.
+ * 
+ * Created on 13. September 2007 by Joerg Schaible
+ */
+package com.thoughtworks.xstream.benchmark.xmlfriendly.target;
+
+import com.thoughtworks.xstream.benchmark.reflection.targets.AbstractReflectionTarget;
+import com.thoughtworks.xstream.benchmark.xmlfriendly.model.A100_Fields;
+import com.thoughtworks.xstream.tools.benchmark.Target;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A Target for a 100 fields class with each field name containing 5 underscores.
+ * 
+ * @author J&ouml;rg Schaible
+ * @see com.thoughtworks.xstream.tools.benchmark.Harness
+ * @see Target
+ */
+public class Field_Reflection extends AbstractReflectionTarget {
+
+    public Field_Reflection() {
+        super(new ArrayList());
+        List list = (List)target();
+        for(int i = 0; i < 100; ++i) {
+            Object o = new A100_Fields();
+            fill(o);
+            list.add(o);
+        }
+    }
+
+    public String toString() {
+        return "Field with underscores Target";
+    }
+
+}