test/jdk/java/util/Map/MapWithCollisionsProviders.java - platform/libcore - Gitiles

 /*
  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.function.Supplier;

 import org.testng.annotations.DataProvider;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.assertEquals;

 public class MapWithCollisionsProviders {

     private static final int TEST_SIZE
             = Boolean.valueOf(System.getProperty("test.map.collisions.shortrun"))
             ? 2500
             : 5000;

     private static final IntKey EXTRA_INTKEY_VAL
             = new IntKey(TEST_SIZE, Integer.MAX_VALUE);

     private static final String EXTRA_STRING_VAL = "Extra Value";

     public static final class IntKey implements Comparable<IntKey> {

         private final int value;
         private final int hashmask; //yes duplication

         IntKey(int value, int hashmask) {
             this.value = value;
             this.hashmask = hashmask;
         }

         @Override
         public boolean equals(Object obj) {
             if (obj instanceof IntKey) {
                 IntKey other = (IntKey) obj;

                 return other.value == value;
             }

             return false;
         }

         @Override
         public int hashCode() {
             return value % hashmask;
         }

         @Override
         public int compareTo(IntKey o) {
             return value - o.value;
         }

         @Override
         public String toString() {
             return Integer.toString(value);
         }

         public int getValue() {
             return value;
         }
     }

     private static Object[] createUniqueObjectKeys() {
         IntKey UNIQUE_OBJECTS[] = new IntKey[TEST_SIZE];
         for (int i = 0; i < TEST_SIZE; i++) {
             UNIQUE_OBJECTS[i] = new IntKey(i, Integer.MAX_VALUE);
         }
         return UNIQUE_OBJECTS;
     }

     private static Object[] createUniqueStringKeys() {
         String UNIQUE_STRINGS[] = new String[TEST_SIZE];
         for (int i = 0; i < TEST_SIZE; i++) {
             UNIQUE_STRINGS[i] = unhash(i);
         }
         return UNIQUE_STRINGS;
     }

     private static Object[] createCollidingObjectKeys() {
         IntKey COLLIDING_OBJECTS[] = new IntKey[TEST_SIZE];
         for (int i = 0; i < TEST_SIZE; i++) {
             COLLIDING_OBJECTS[i] = new IntKey(i, 10);
         }
         return COLLIDING_OBJECTS;
     }

     private static Object[] createCollidingStringKeys() {
         String COLLIDING_STRINGS[] = new String[TEST_SIZE];
         String UNIQUE_STRINGS[] = new String[TEST_SIZE];
         for (int i = 0; i < TEST_SIZE; i++) {
             UNIQUE_STRINGS[i] = unhash(i);
             COLLIDING_STRINGS[i] = (0 == i % 2)
                     ? UNIQUE_STRINGS[i / 2]
                     : "\u0000\u0000\u0000\u0000\u0000" + COLLIDING_STRINGS[i - 1];
         }
         return COLLIDING_STRINGS;
     }

     /**
      * Returns a string with a hash equal to the argument.
      *
      * @return string with a hash equal to the argument.
      */
     private static String unhash(int target) {
         StringBuilder answer = new StringBuilder();
         if (target < 0) {
             // String with hash of Integer.MIN_VALUE, 0x80000000
             answer.append("\\u0915\\u0009\\u001e\\u000c\\u0002");

             if (target == Integer.MIN_VALUE) {
                 return answer.toString();
             }
             // Find target without sign bit set
             target = target & Integer.MAX_VALUE;
         }

         unhash0(answer, target);
         return answer.toString();
     }

     private static void unhash0(StringBuilder partial, int target) {
         int div = target / 31;
         int rem = target % 31;

         if (div <= Character.MAX_VALUE) {
             if (div != 0) {
                 partial.append((char) div);
             }
             partial.append((char) rem);
         } else {
             unhash0(partial, div);
             partial.append((char) rem);
         }
     }

     private static <T> Map<T, T> fillMap(Map<T, T> m, T[] keys) {
         for (T k : keys) {
             m.put(k, k);
             assertTrue(m.containsKey(k));
             assertTrue(m.containsValue(k));
         }
         assertEquals(m.size(), keys.length);
         return m;
     }

     private static <T> Supplier<Map<T, T>> createMap(Map<T, T> m, T[] keys) {
         return () -> fillMap(m, keys);
     }

     private static <T> Object[] createCase(String desc, Map<T, T> m, T[] keys, T val) {
         return new Object[]{desc, createMap(m, keys), val};
     }

     private static <T> Collection<Object[]> makeMapsMoreTypes(String desc,
                                                               T[] keys,
                                                               T val) {
         Collection<Object[]> cases = new ArrayList<>();
         cases.add(createCase("Hashtable with " + desc,
                              new Hashtable<>(), keys, val));
         cases.add(createCase("IdentityHashMap with " + desc,
                              new IdentityHashMap<>(), keys, val));
         cases.add(createCase("TreeMap with " + desc,
                              new TreeMap<>(), keys, val));
         cases.add(createCase("WeakHashMap with " + desc,
                              new WeakHashMap<>(), keys, val));
         cases.add(createCase("ConcurrentHashMap with " + desc,
                              new ConcurrentHashMap<>(), keys, val));
         cases.add(createCase("ConcurrentSkipListMap with " + desc,
                              new ConcurrentSkipListMap<>(), keys, val));
         return cases;
     }

     private static <T> Collection<Object[]> makeMapsHashMap(String desc,
                                                             T[] keys,
                                                             T val) {
         Collection<Object[]> cases = new ArrayList<>();
         cases.add(createCase("HashMap with " + desc,
                              new HashMap<>(), keys, val));
         cases.add(createCase("LinkedHashMap with " + desc,
                              new LinkedHashMap<>(), keys, val));
         return cases;
     }

     private static <T> Collection<Object[]> makeMaps(String desc, T[] keys, T val) {
         Collection<Object[]> cases = new ArrayList<>();
         cases.addAll(makeMapsHashMap(desc, keys, val));
         cases.addAll(makeMapsMoreTypes(desc, keys, val));
         return cases;
     }

     private static <T> Collection<Object[]> makeObjectsCases(String desc, T[] keys) {
         return makeMaps(desc, keys, EXTRA_INTKEY_VAL);
     }

     private static <T> Collection<Object[]> makeStringsCases(String desc,
             T[] keys) {
         return makeMaps(desc, keys, EXTRA_STRING_VAL);
     }

     private static final Collection<Object[]> mapsWithObjectsCases
             = new ArrayList<>() {
         {
             addAll(makeObjectsCases("unique objects", createUniqueObjectKeys()));
             addAll(makeObjectsCases("colliding objects", createCollidingObjectKeys()));
         }
     };

     private static final Collection<Object[]> mapsWithStringsCases
             = new ArrayList<>() {
         {
             addAll(makeStringsCases("unique strings", createUniqueStringKeys()));
             addAll(makeStringsCases("colliding strings", createCollidingStringKeys()));
         }
     };

     private static final Collection<Object[]> mapsWithObjectsAndStringsCases
             = new ArrayList<>() {
         {
             addAll(mapsWithObjectsCases);
             addAll(mapsWithStringsCases);
         }
     };

     private static final Collection<Object[]> hashMapsWithObjectsCases
             = new ArrayList<>() {
         {
             addAll(makeMapsHashMap("unique objects",
                 createUniqueObjectKeys(), EXTRA_INTKEY_VAL));
             addAll(makeMapsHashMap("collisions objects",
                 createCollidingObjectKeys(), EXTRA_INTKEY_VAL));
         }
     };

     @DataProvider
     public Iterator<Object[]> mapsWithObjects() {
         return mapsWithObjectsCases.iterator();
     }

     @DataProvider
     public Iterator<Object[]> mapsWithStrings() {
         return mapsWithStringsCases.iterator();
     }

     @DataProvider
     public Iterator<Object[]> mapsWithObjectsAndStrings() {
         return mapsWithObjectsAndStringsCases.iterator();
     }

     @DataProvider
     public Iterator<Object[]> hashMapsWithObjects() {
         return hashMapsWithObjectsCases.iterator();
     }

 }
	/*
	* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.Hashtable;
	import java.util.IdentityHashMap;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.TreeMap;
	import java.util.WeakHashMap;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.ConcurrentSkipListMap;
	import java.util.function.Supplier;

	import org.testng.annotations.DataProvider;
	import static org.testng.Assert.assertTrue;
	import static org.testng.Assert.assertEquals;

	public class MapWithCollisionsProviders {

	private static final int TEST_SIZE
	= Boolean.valueOf(System.getProperty("test.map.collisions.shortrun"))
	? 2500
	: 5000;

	private static final IntKey EXTRA_INTKEY_VAL
	= new IntKey(TEST_SIZE, Integer.MAX_VALUE);

	private static final String EXTRA_STRING_VAL = "Extra Value";

	public static final class IntKey implements Comparable<IntKey> {

	private final int value;
	private final int hashmask; //yes duplication

	IntKey(int value, int hashmask) {
	this.value = value;
	this.hashmask = hashmask;
	}

	@Override
	public boolean equals(Object obj) {
	if (obj instanceof IntKey) {
	IntKey other = (IntKey) obj;

	return other.value == value;
	}

	return false;
	}

	@Override
	public int hashCode() {
	return value % hashmask;
	}

	@Override
	public int compareTo(IntKey o) {
	return value - o.value;
	}

	@Override
	public String toString() {
	return Integer.toString(value);
	}

	public int getValue() {
	return value;
	}
	}

	private static Object[] createUniqueObjectKeys() {
	IntKey UNIQUE_OBJECTS[] = new IntKey[TEST_SIZE];
	for (int i = 0; i < TEST_SIZE; i++) {
	UNIQUE_OBJECTS[i] = new IntKey(i, Integer.MAX_VALUE);
	}
	return UNIQUE_OBJECTS;
	}

	private static Object[] createUniqueStringKeys() {
	String UNIQUE_STRINGS[] = new String[TEST_SIZE];
	for (int i = 0; i < TEST_SIZE; i++) {
	UNIQUE_STRINGS[i] = unhash(i);
	}
	return UNIQUE_STRINGS;
	}

	private static Object[] createCollidingObjectKeys() {
	IntKey COLLIDING_OBJECTS[] = new IntKey[TEST_SIZE];
	for (int i = 0; i < TEST_SIZE; i++) {
	COLLIDING_OBJECTS[i] = new IntKey(i, 10);
	}
	return COLLIDING_OBJECTS;
	}

	private static Object[] createCollidingStringKeys() {
	String COLLIDING_STRINGS[] = new String[TEST_SIZE];
	String UNIQUE_STRINGS[] = new String[TEST_SIZE];
	for (int i = 0; i < TEST_SIZE; i++) {
	UNIQUE_STRINGS[i] = unhash(i);
	COLLIDING_STRINGS[i] = (0 == i % 2)
	? UNIQUE_STRINGS[i / 2]
	: "\u0000\u0000\u0000\u0000\u0000" + COLLIDING_STRINGS[i - 1];
	}
	return COLLIDING_STRINGS;
	}

	/**
	* Returns a string with a hash equal to the argument.
	*
	* @return string with a hash equal to the argument.
	*/
	private static String unhash(int target) {
	StringBuilder answer = new StringBuilder();
	if (target < 0) {
	// String with hash of Integer.MIN_VALUE, 0x80000000
	answer.append("\\u0915\\u0009\\u001e\\u000c\\u0002");

	if (target == Integer.MIN_VALUE) {
	return answer.toString();
	}
	// Find target without sign bit set
	target = target & Integer.MAX_VALUE;
	}

	unhash0(answer, target);
	return answer.toString();
	}

	private static void unhash0(StringBuilder partial, int target) {
	int div = target / 31;
	int rem = target % 31;

	if (div <= Character.MAX_VALUE) {
	if (div != 0) {
	partial.append((char) div);
	}
	partial.append((char) rem);
	} else {
	unhash0(partial, div);
	partial.append((char) rem);
	}
	}

	private static <T> Map<T, T> fillMap(Map<T, T> m, T[] keys) {
	for (T k : keys) {
	m.put(k, k);
	assertTrue(m.containsKey(k));
	assertTrue(m.containsValue(k));
	}
	assertEquals(m.size(), keys.length);
	return m;
	}

	private static <T> Supplier<Map<T, T>> createMap(Map<T, T> m, T[] keys) {
	return () -> fillMap(m, keys);
	}

	private static <T> Object[] createCase(String desc, Map<T, T> m, T[] keys, T val) {
	return new Object[]{desc, createMap(m, keys), val};
	}

	private static <T> Collection<Object[]> makeMapsMoreTypes(String desc,
	T[] keys,
	T val) {
	Collection<Object[]> cases = new ArrayList<>();
	cases.add(createCase("Hashtable with " + desc,
	new Hashtable<>(), keys, val));
	cases.add(createCase("IdentityHashMap with " + desc,
	new IdentityHashMap<>(), keys, val));
	cases.add(createCase("TreeMap with " + desc,
	new TreeMap<>(), keys, val));
	cases.add(createCase("WeakHashMap with " + desc,
	new WeakHashMap<>(), keys, val));
	cases.add(createCase("ConcurrentHashMap with " + desc,
	new ConcurrentHashMap<>(), keys, val));
	cases.add(createCase("ConcurrentSkipListMap with " + desc,
	new ConcurrentSkipListMap<>(), keys, val));
	return cases;
	}

	private static <T> Collection<Object[]> makeMapsHashMap(String desc,
	T[] keys,
	T val) {
	Collection<Object[]> cases = new ArrayList<>();
	cases.add(createCase("HashMap with " + desc,
	new HashMap<>(), keys, val));
	cases.add(createCase("LinkedHashMap with " + desc,
	new LinkedHashMap<>(), keys, val));
	return cases;
	}

	private static <T> Collection<Object[]> makeMaps(String desc, T[] keys, T val) {
	Collection<Object[]> cases = new ArrayList<>();
	cases.addAll(makeMapsHashMap(desc, keys, val));
	cases.addAll(makeMapsMoreTypes(desc, keys, val));
	return cases;
	}

	private static <T> Collection<Object[]> makeObjectsCases(String desc, T[] keys) {
	return makeMaps(desc, keys, EXTRA_INTKEY_VAL);
	}

	private static <T> Collection<Object[]> makeStringsCases(String desc,
	T[] keys) {
	return makeMaps(desc, keys, EXTRA_STRING_VAL);
	}

	private static final Collection<Object[]> mapsWithObjectsCases
	= new ArrayList<>() {
	{
	addAll(makeObjectsCases("unique objects", createUniqueObjectKeys()));
	addAll(makeObjectsCases("colliding objects", createCollidingObjectKeys()));
	}
	};

	private static final Collection<Object[]> mapsWithStringsCases
	= new ArrayList<>() {
	{
	addAll(makeStringsCases("unique strings", createUniqueStringKeys()));
	addAll(makeStringsCases("colliding strings", createCollidingStringKeys()));
	}
	};

	private static final Collection<Object[]> mapsWithObjectsAndStringsCases
	= new ArrayList<>() {
	{
	addAll(mapsWithObjectsCases);
	addAll(mapsWithStringsCases);
	}
	};

	private static final Collection<Object[]> hashMapsWithObjectsCases
	= new ArrayList<>() {
	{
	addAll(makeMapsHashMap("unique objects",
	createUniqueObjectKeys(), EXTRA_INTKEY_VAL));
	addAll(makeMapsHashMap("collisions objects",
	createCollidingObjectKeys(), EXTRA_INTKEY_VAL));
	}
	};

	@DataProvider
	public Iterator<Object[]> mapsWithObjects() {
	return mapsWithObjectsCases.iterator();
	}

	@DataProvider
	public Iterator<Object[]> mapsWithStrings() {
	return mapsWithStringsCases.iterator();
	}

	@DataProvider
	public Iterator<Object[]> mapsWithObjectsAndStrings() {
	return mapsWithObjectsAndStringsCases.iterator();
	}

	@DataProvider
	public Iterator<Object[]> hashMapsWithObjects() {
	return hashMapsWithObjectsCases.iterator();
	}

	}