--- jsr166/src/test/tck/ConcurrentHashMapTest.java	2013/04/11 20:03:44	1.30
+++ jsr166/src/test/tck/ConcurrentHashMapTest.java	2013/07/20 16:53:40	1.35
@@ -34,12 +34,15 @@ public class ConcurrentHashMapTest exten
         return map;
     }
 
+    /** Re-implement Integer.compare for old java versions */
+    static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
+
     // classes for testing Comparable fallbacks
     static class BI implements Comparable<BI> {
         private final int value;
         BI(int value) { this.value = value; }
         public int compareTo(BI other) {
-            return Integer.compare(value, other.value);
+            return compare(value, other.value);
         }
         public boolean equals(Object x) {
             return (x instanceof BI) && ((BI)x).value == value;
@@ -73,18 +76,35 @@ public class ConcurrentHashMapTest exten
                     break;
             }
             if (r == 0)
-                r = Integer.compare(size(), other.size());
+                r = compare(size(), other.size());
             return r;
         }
         private static final long serialVersionUID = 0;
     }
 
+    static class CollidingObject {
+        final String value;
+        CollidingObject(final String value) { this.value = value; }
+        public int hashCode() { return this.value.hashCode() & 1; }
+        public boolean equals(final Object obj) {
+            return (obj instanceof CollidingObject) && ((CollidingObject)obj).value.equals(value);
+        }
+    }
+
+    static class ComparableCollidingObject extends CollidingObject implements Comparable<ComparableCollidingObject> {
+        ComparableCollidingObject(final String value) { super(value); }
+        public int compareTo(final ComparableCollidingObject o) {
+            return value.compareTo(o.value);
+        }
+    }
+
     /**
      * Inserted elements that are subclasses of the same Comparable
      * class are found.
      */
     public void testComparableFamily() {
-        ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
+        ConcurrentHashMap<BI, Boolean> m =
+            new ConcurrentHashMap<BI, Boolean>();
         for (int i = 0; i < 1000; i++) {
             assertTrue(m.put(new CI(i), true) == null);
         }
@@ -99,7 +119,8 @@ public class ConcurrentHashMapTest exten
      * on Comparable can be inserted and found.
      */
     public void testGenericComparable() {
-        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
+        ConcurrentHashMap<Object, Boolean> m =
+            new ConcurrentHashMap<Object, Boolean>();
         for (int i = 0; i < 1000; i++) {
             BI bi = new BI(i);
             BS bs = new BS(String.valueOf(i));
@@ -122,7 +143,8 @@ public class ConcurrentHashMapTest exten
      * inserted and found.
      */
     public void testGenericComparable2() {
-        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
+        ConcurrentHashMap<Object, Boolean> m =
+            new ConcurrentHashMap<Object, Boolean>();
         for (int i = 0; i < 1000; i++) {
             m.put(new ArrayList(Collections.singleton(new BI(i))), true);
         }
@@ -134,6 +156,41 @@ public class ConcurrentHashMapTest exten
     }
 
     /**
+     * Mixtures of instances of comparable and non-comparable classes
+     * can be inserted and found.
+     */
+    public void testMixedComparable() {
+        int size = 10000;
+        ConcurrentHashMap<Object, Object> map =
+            new ConcurrentHashMap<Object, Object>();
+        Random rng = new Random(1370014958369218000L);
+        for (int i = 0; i < size; i++) {
+            Object x;
+            switch (rng.nextInt(4)) {
+            case 0:
+                x = new Object();
+                break;
+            case 1:
+                x = new CollidingObject(Integer.toString(i));
+                break;
+            default:
+                x = new ComparableCollidingObject(Integer.toString(i));
+            }
+            assertNull(map.put(x, x));
+        }
+        int count = 0;
+        for (Object k : map.keySet()) {
+            assertEquals(map.get(k), k);
+            ++count;
+        }
+        assertEquals(count, size);
+        assertEquals(map.size(), size);
+        for (Object k : map.keySet()) {
+            assertEquals(map.put(k, k), k);
+        }
+    }
+
+    /**
      * clear removes all pairs
      */
     public void testClear() {
@@ -651,7 +708,7 @@ public class ConcurrentHashMapTest exten
         Map x = map5();
         Map y = serialClone(x);
 
-        assertTrue(x != y);
+        assertNotSame(x, y);
         assertEquals(x.size(), y.size());
         assertEquals(x, y);
         assertEquals(y, x);