gnu.trove.map.hash.THashMapTest Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
Show all versions of core Show documentation
High performance collections for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2001-2006, Eric D. Friedman All Rights Reserved.
// Copyright (c) 2009, Rob Eden All Rights Reserved.
// Copyright (c) 2009, Jeff Randall All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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 for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
///////////////////////////////////////////////////////////////////////////////
package gnu.trove.map.hash;
import gnu.trove.function.TObjectFunction;
import gnu.trove.impl.hash.HashTestKit;
import gnu.trove.impl.hash.TByteByteHash;
import gnu.trove.impl.hash.TObjectHash;
import gnu.trove.procedure.TObjectObjectProcedure;
import gnu.trove.procedure.TObjectProcedure;
import gnu.trove.set.hash.THashSet;
import gnu.trove.set.hash.THashSetTest;
import junit.framework.TestCase;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.*;
/**
* Created: Sat Nov 3 10:31:38 2001
*
* @author Eric D. Friedman
* @author Rob Eden
* @author Jeff Randall
* @version $Id: THashMapTest.java,v 1.1.2.7 2010/03/02 04:09:50 robeden Exp $
*/
public class THashMapTest extends TestCase {
protected THashMap ss_map;
protected THashMap si_map;
protected int count;
public THashMapTest( String name ) {
super( name );
}
public void setUp() throws Exception {
super.setUp();
ss_map = new THashMap();
si_map = new THashMap();
count = 0;
}
public void tearDown() throws Exception {
super.tearDown();
ss_map = null;
si_map = null;
count = 0;
}
public void testConstructors() {
String[] keys = {"Key1", "Key2", "Key3", "Key4", "Key5"};
String[] values = {"Val1", "Val2", "Val3", "Val4", "Val5"};
for ( int i = 0; i < keys.length; i++ ) {
ss_map.put( keys[i], values[i] );
}
THashMap sized = new THashMap( 100 );
for ( int i = 0; i < keys.length; i++ ) {
sized.put( keys[i], values[i] );
}
assertTrue( "maps should be a copy of each other", ss_map.equals( sized ) );
THashMap factor = new THashMap( 100, 1.0f );
for ( int i = 0; i < keys.length; i++ ) {
factor.put( keys[i], values[i] );
}
assertTrue( "maps should be a copy of each other", ss_map.equals( factor ) );
THashMap copy = new THashMap( ss_map );
assertTrue( "maps should be a copy of each other", ss_map.equals( copy ) );
for ( int i = 0; i < keys.length; i++ ) {
assertEquals( values[i], copy.get( keys[i] ) );
}
Map java_hashmap = new HashMap();
for ( int i = 0; i < keys.length; i++ ) {
java_hashmap.put( keys[i], values[i] );
}
THashMap java_hashmap_copy =
new THashMap( java_hashmap );
assertTrue( "maps should be a copy of each other",
ss_map.equals( java_hashmap_copy ) );
}
// x'd out because we don't usually run tests with > 4gb heaps
public void xxtestLargeCapacity() throws Exception {
TByteByteHash large = new TByteByteHashMap(Integer.MAX_VALUE);
assertTrue( "capacity was not respected", large.capacity() > 3 );
}
public void testEquals() {
String[] keys = {"Key1", "Key2", "Key3", "Key4", "Key5"};
String[] values = {"Val1", "Val2", "Val3", "Val4", "Val5"};
for ( int i = 0; i < keys.length; i++ ) {
ss_map.put( keys[i], values[i] );
}
assertFalse( "should not equal random Object", ss_map.equals( new Object() ) );
THashMap copy = new THashMap( ss_map );
assertTrue( "maps should be a copy of each other", ss_map.equals( copy ) );
// Change the Length.
copy.put( "Key6", "Val6" );
assertFalse( "maps should no longer be a copy of each other",
ss_map.equals( copy ) );
}
public void testPut() throws Exception {
assertEquals( "put succeeded", null, ss_map.put( "One", "two" ) );
assertEquals( "size did not reflect put", 1, ss_map.size() );
assertEquals( "put/get failed", "two", ss_map.get( "One" ) );
assertEquals( "second put failed", "two", ss_map.put( "One", "foo" ) );
}
public void testPutIfAbsent() throws Exception {
assertEquals( "putIfAbsent succeeded", null, ss_map.putIfAbsent( "One", "two" ) );
assertEquals( "size did not reflect putIfAbsent", 1, ss_map.size() );
assertEquals( "putIfAbsent/get failed", "two", ss_map.get( "One" ) );
assertEquals( "second putIfAbsent failed", "two", ss_map.putIfAbsent( "One", "foo" ) );
assertEquals( "size did not reflect putIfAbsent", 1, ss_map.size() );
assertEquals( "putIfAbsent/get failed", "two", ss_map.get( "One" ) );
assertEquals( "third putIfAbsent failed", null, ss_map.putIfAbsent( "Two", "bar" ) );
assertEquals( "size did not reflect putIfAbsent", 2, ss_map.size() );
assertEquals( "putIfAbsent/get failed", "bar", ss_map.get( "Two" ) );
}
public void testClear() throws Exception {
assertEquals( "initial size was not zero", 0, ss_map.size() );
assertEquals( "put succeeded", null, ss_map.put( "One", "two" ) );
assertEquals( "size did not reflect put", 1, ss_map.size() );
ss_map.clear();
assertEquals( "cleared size was not zero", 0, ss_map.size() );
}
public void testContains() throws Exception {
String key = "hi";
assertTrue( "should not contain key initially", !si_map.contains( key ) );
assertEquals( "put succeeded", null, si_map.put( key, Integer.valueOf( 1 ) ) );
assertTrue( "key not found after put", si_map.contains( key ) );
assertFalse( "non-existant key found", si_map.contains( "bye" ) );
}
public void testContainsKey() throws Exception {
String key = "hi";
assertTrue( "should not contain key initially", !si_map.containsKey( key ) );
assertEquals( "put succeeded", null, si_map.put( key, Integer.valueOf( 1 ) ) );
assertTrue( "key not found after put", si_map.containsKey( key ) );
assertFalse( "non-existant key found", si_map.containsKey( "bye" ) );
}
public void testContainsValue() throws Exception {
String key = "hi";
String value = "bye";
assertTrue( "should not contain key initially", !ss_map.containsValue( value ) );
assertEquals( "put succeeded", null, ss_map.put( key, value ) );
assertTrue( "key not found after put", ss_map.containsValue( value ) );
assertFalse( "non-existant key found", ss_map.containsValue( "whee" ) );
}
@SuppressWarnings({"SuspiciousMethodCalls"})
public void testGet() throws Exception {
String key = "hi", val = "one", val2 = "two";
ss_map.put( key, val );
assertEquals( "get did not return expected value", val, ss_map.get( key ) );
ss_map.put( key, val2 );
assertEquals( "get did not return expected value on second put",
val2, ss_map.get( key ) );
// Invalid key should return null
assertNull( ss_map.get( new Object() ) );
}
public void testValues() throws Exception {
String k1 = "1", k2 = "2", k3 = "3", k4 = "4", k5 = "5";
String v1 = "x", v2 = "y", v3 = "z";
ss_map.put( k1, v1 );
ss_map.put( k2, v1 );
ss_map.put( k3, v2 );
ss_map.put( k4, v3 );
ss_map.put( k5, v2 );
Collection vals = ss_map.values();
assertEquals( "size was not 5", 5, vals.size() );
vals.remove( "z" );
assertEquals( "size was not 4", 4, vals.size() );
vals.remove( "y" );
assertEquals( "size was not 3", 3, vals.size() );
vals.remove( "y" );
assertEquals( "size was not 2", 2, vals.size() );
assertEquals( "map did not diminish to 2 entries", 2, ss_map.size() );
}
@SuppressWarnings({"WhileLoopReplaceableByForEach"})
public void testKeySet() throws Exception {
String key1 = "hi", key2 = "bye", key3 = "whatever";
String val = "x";
ss_map.put( key1, val );
ss_map.put( key2, val );
ss_map.put( key3, val );
Set keys = ss_map.keySet();
assertTrue( "keyset did not match expected set",
keys.containsAll( Arrays.asList( key1, key2, key3 ) ) );
assertEquals( 3, ss_map.size() );
int count = 0;
Iterator it = keys.iterator();
while ( it.hasNext() ) {
count++;
it.next();
}
assertEquals( ss_map.size(), count );
for ( Iterator i = keys.iterator(); i.hasNext(); ) {
Object o = i.next();
if ( o.equals( key2 ) ) {
i.remove();
}
}
assertTrue( "keyset did not match expected set",
keys.containsAll( Arrays.asList( key1, key3 ) ) );
}
public void testForEachKey() throws Exception {
THashMap map = new THashMap();
String[] vals = {"one", "two", "three", "four"};
Integer[] keys = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
map.put( keys[i], vals[i] );
}
TObjectProcedure proc =
new TObjectProcedure() {
public boolean execute( Integer value ) {
count += value;
return true;
}
};
assertTrue( "should complete successfully", map.forEachKey( proc ) );
assertEquals( 10, count );
}
public void testForEachKeyFalse() throws Exception {
THashMap map = new THashMap();
String[] vals = {"one", "two", "three", "four"};
Integer[] keys = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
map.put( keys[i], vals[i] );
}
TObjectProcedure proc =
new TObjectProcedure() {
public boolean execute( Integer value ) {
count++;
return false;
}
};
assertFalse( "should Break after first iteration", map.forEachKey( proc ) );
assertEquals( 1, count );
}
public void testForEachValue() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
TObjectProcedure proc =
new TObjectProcedure() {
public boolean execute( Integer value ) {
count += value;
return true;
}
};
si_map.forEachValue( proc );
assertEquals( 10, count );
}
public void testForEachValueFalse() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
TObjectProcedure proc =
new TObjectProcedure() {
public boolean execute( Integer value ) {
count++;
return false;
}
};
assertFalse( "should Break after first iteration", si_map.forEachValue( proc ) );
assertEquals( 1, count );
}
public void testForEachEntry() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
TObjectObjectProcedure proc =
new TObjectObjectProcedure() {
public boolean execute( String key, Integer value ) {
count += value;
return true;
}
};
si_map.forEachEntry( proc );
assertEquals( 10, count );
}
public void testForEachEntryInterrupt() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
TObjectObjectProcedure proc =
new TObjectObjectProcedure() {
public boolean execute( String key, Integer value ) {
count += value;
return count < 6;
}
};
si_map.forEachEntry( proc );
assertTrue( count < 10 );
}
public void testTransformValues() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
TObjectFunction func =
new TObjectFunction() {
public Integer execute( Integer value ) {
return new Integer( value << 1 );
}
};
si_map.transformValues( func );
assertEquals( new Integer( 2 ), si_map.get( "one" ) );
assertEquals( new Integer( 4 ), si_map.get( "two" ) );
assertEquals( new Integer( 6 ), si_map.get( "three" ) );
assertEquals( new Integer( 8 ), si_map.get( "four" ) );
}
@SuppressWarnings({"ForLoopReplaceableByForEach"})
public void testKeyIterator() throws Exception {
String[] keys = {"one", "two", "three", "four"};
Integer[] vals = {new Integer( 1 ),
new Integer( 2 ),
new Integer( 3 ),
new Integer( 4 )
};
for ( int i = 0; i < keys.length; i++ ) {
si_map.put( keys[i], vals[i] );
}
int count = 0;
for ( Iterator i = si_map.keySet().iterator(); i.hasNext(); ) {
i.next();
count++;
}
assertEquals( 4, count );
}
public void testContainsNullValue() throws Exception {
si_map.put( "a", null );
assertTrue( si_map.containsValue( null ) );
}
public void testEntrySetContainsEntryWithNullValue() throws Exception {
si_map.put( "0", null );
Map.Entry ee = si_map.entrySet().iterator().next();
assertTrue( si_map.entrySet().contains( ee ) );
}
public void testValueSetRemoveNullValue() throws Exception {
si_map.put( "0", null );
assertTrue( si_map.values().remove( null ) );
}
public void testSizeAfterEntrySetRemove() throws Exception {
si_map.put( "0", null );
Map.Entry ee = si_map.entrySet().iterator().next();
assertTrue( ee.getKey().equals( "0" ) );
assertNull( ee.getValue() );
assertTrue( "remove on entrySet() returned false",
si_map.entrySet().remove( ee ) );
assertEquals( 0, si_map.size() );
}
@SuppressWarnings({"SuspiciousMethodCalls"})
public void testEntrySetRemoveSameKeyDifferentValues() throws Exception {
ss_map.put( "0", "abc" );
si_map.put( "0", Integer.valueOf( 123 ) );
Map.Entry ee = ss_map.entrySet().iterator().next();
assertEquals( 1, si_map.size() );
assertTrue( !si_map.entrySet().contains( ee ) );
assertTrue( !si_map.entrySet().remove( ee ) );
}
public void testSizeAfterMultipleReplacingPuts() throws Exception {
ss_map.put( "key", "a" );
assertEquals( 1, ss_map.size() );
ss_map.put( "key", "b" );
assertEquals( 1, ss_map.size() );
}
@SuppressWarnings({"unchecked"})
public void testSerializable() throws Exception {
// Use a non-standard load factor to more fully test serialization
THashMap map = new THashMap( 100, 0.75f );
map.put( "a", "b" );
map.put( "b", "c" );
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream( baos );
oos.writeObject( map );
ByteArrayInputStream bais = new ByteArrayInputStream( baos.toByteArray() );
ObjectInputStream ois = new ObjectInputStream( bais );
THashMap deserialized = (THashMap) ois.readObject();
assertEquals( map, deserialized );
}
public void testRetainEntries() throws Exception {
ss_map.put( "a", "b" );
ss_map.put( "c", "b" );
ss_map.put( "d", "b" );
ss_map.retainEntries( new TObjectObjectProcedure() {
public boolean execute( String key, String val ) {
return key.equals( "c" );
}
} );
assertEquals( 1, ss_map.size() );
assertTrue( ss_map.containsKey( "c" ) );
assertEquals( "b", ss_map.get( "c" ) );
}
public void testPutAll() throws Exception {
HashMap map = new HashMap();
map.put( "one", "two" );
map.put( "two", "four" );
map.put( "three", "six" );
ss_map.putAll( map );
}
@SuppressWarnings({"RedundantStringConstructorCall"})
public void testHashCode() throws Exception {
THashMap ss_map2 = new THashMap();
ss_map.put( new String( "foo" ), new String( "bar" ) );
ss_map2.put( new String( "foo" ), new String( "bar" ) );
assertEquals( ss_map.hashCode(), ss_map2.hashCode() );
assertEquals( ss_map, ss_map2 );
ss_map2.put( new String( "cruft" ), new String( "bar" ) );
assertTrue( ss_map.hashCode() != ss_map2.hashCode() );
assertTrue( !ss_map.equals( ss_map2 ) );
}
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
public void testBadlyWrittenKey() {
THashMap map = new THashMap();
boolean didThrow = false;
try {
for ( int i = 0; i < 1000; i++ ) { // enough to trigger a rehash
map.put( new THashSetTest.Crap(), new Integer( i ) );
}
}
catch ( IllegalArgumentException e ) {
didThrow = true;
}
assertTrue( "expected THashMap to throw an IllegalArgumentException", didThrow );
}
public void testKeySetEqualsEquivalentSet() {
Set set = new HashSet();
set.add( "foo" );
set.add( "doh" );
set.add( "hal" );
THashMap tv1 = new THashMap();
tv1.put( "doh", "blah" );
tv1.put( "foo", "blah" );
tv1.put( "hal", "notblah" );
assertTrue( tv1.keySet().equals( set ) );
}
@SuppressWarnings({"unchecked"})
public void testNullValue() {
ss_map.put( "foo", null );
ss_map.put( "bar", null );
ss_map.put( "baz", null );
assertEquals( Arrays.asList( null, null, null ), new ArrayList( ss_map.values() ) );
}
public void testNullValueSize() {
ss_map.put( "narf", null );
ss_map.put( "narf", null );
assertEquals( 1, ss_map.size() );
}
public void testNullKey() {
ss_map.put( null, "null" );
assertEquals( null, ss_map.keySet().iterator().next() );
ss_map.put( "one", "1" );
ss_map.put( "two", "2" );
ss_map.put( "three", "3" );
assertEquals( "null", ss_map.get( null ) );
assertEquals( "1", ss_map.get( "one" ) );
assertEquals( "2", ss_map.get( "two" ) );
assertEquals( "3", ss_map.get( "three" ) );
String old_value = ss_map.put( null, "null_new" );
assertEquals( "null", old_value );
assertEquals( "null_new", ss_map.get( null ) );
}
public void testRetainEntrySet() {
ss_map.put( "one", "frodo" );
ss_map.put( "two", "bilbo" );
ss_map.put( "three", "samwise" );
Map subset = new HashMap();
subset.put( "two", "bilbo" );
assertTrue( ss_map.entrySet().retainAll( subset.entrySet() ) );
assertEquals( subset, ss_map );
}
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
public void testMapEntrySetHashCode() {
ss_map.put( "one", "foo" );
Map m2 = new THashMap();
m2.put( "one", "foo" );
Object o1 = ss_map.entrySet().iterator().next();
Object o2 = ss_map.entrySet().iterator().next();
assertTrue( o1 != o2 );
assertTrue( o1.equals( o2 ) );
assertEquals( o1.hashCode(), o2.hashCode() );
}
public void testEqualsAndHashCode() {
THashMap map1 = new THashMap();
map1.put( "Key1", null );
THashMap map2 = new THashMap();
map2.put( "Key2", "Value2" );
assertFalse( "map1.equals( map2 )", map1.equals( map2 ) );
assertFalse( "map2.equals( map1 )", map2.equals( map1 ) );
THashMap clone_map1 = new THashMap( map1 );
THashMap clone_map2 = new THashMap( map2 );
assertEquals( map1, clone_map1 );
assertEquals( map1.hashCode(), clone_map1.hashCode() );
assertEquals( map2, clone_map2 );
assertEquals( map2.hashCode(), clone_map2.hashCode() );
}
/**
* Test case for bug #1428614.
* http://sourceforge.net/tracker/index.php?func=detail&aid=1428614&group_id=39235&atid=424682
*/
public void testRemoveValue() {
ss_map.put( "one", "a" );
ss_map.put( "two", "a" );
ss_map.put( "three", "b" );
assertEquals( 3, ss_map.size() );
ss_map.values().remove( "a" );
assertEquals( 2, ss_map.size() );
assertFalse( ss_map.values().remove( "non-existant" ) );
}
/**
* This test case arose out of a problem that was ultimately caused by the
* implementation if THashMap.removeAt(int) being incorrect (the super implementation
* was being called before the local implementation which caused problems when
* auto-compaction occurred). So, it's a little wiggy, but since the case was useful
* once, I figure I'll leave it in. - RDE
*/
@SuppressWarnings({"ForLoopReplaceableByForEach",
"MismatchedQueryAndUpdateOfCollection"})
public void testProblematicRemove() {
int[] to_add = new int[]{
9707851, 1432929, 7941420, 8698105, 9178562, 14368620, 2165498, 5759024,
4160722, 1835074, 5570057, 15866937, 1774305, 7645103, 11340758, 14962053,
10326974, 5153366, 8644308, 10981652, 2484113, 8790215, 13765491, 15579334,
16644662, 3538325, 10183070, 2491991, 6963721, 1406388, 14845099, 7614579,
1630785, 11417789, 988981, 12372702, 11197485, 6115155, 185310, 10733210,
4444363, 4256211, 12877269, 2178642, 8551718, 15095256, 922983, 10434400,
15511986, 8792944, 9301853, 6147907, 13778707, 2822511, 8760514, 1112301,
4624291, 8406178, 1708017, 834479, 16113199, 13501060, 477791, 10737091,
2568325, 14839924, 4523777, 13566852, 15722007, 15406704, 932352, 127549,
13010531, 10540591, 5100961, 288048, 9396085, 12844726, 8887992, 12932686,
10827776, 16751176, 15337379, 10192984, 1341540, 15470105, 9555179, 2394843,
1595902, 12345969, 14884594, 313940, 8348091, 15293845, 16706146, 13500767,
12331344, 3959435, 7796580, 7077998, 9458485, 4648605, 14396291, 14246507,
13404097, 14988605, 3600161, 9280290, 12842832, 10606027, 14355582, 1136752,
12921165, 1749219, 5457859, 9197696, 421256, 73503, 10633537, 6952660,
58264, 6164651, 9993341, 1386282, 12470635, 12982240, 4816459, 159250,
8949093, 16447937, 2290043, 1828537, 13148199, 9084516, 10802630, 13549340,
6609445, 2995162, 8040282, 9333002, 9580969, 16406600, 12194236, 14835440,
13041360, 8604473, 12565810, 1988729, 4355359, 1535580, 5149176, 5324752,
3438993, 1660570, 8691895, 5474195, 15334260, 8105437, 13879037, 11351030,
3039475, 14625682, 10849417, 11379670, 14640675, 11176427, 4513965, 16428465,
10578701, 8072595, 15538803, 6526027, 10283251, 8507206, 5188636, 14223982,
3920972, 15659969, 12922874, 13689914, 3658005, 8379437, 5247277, 9938991,
10659712, 10678905, 14485926, 10786998, 2488171, 9881794, 5651833, 14538812,
10444169, 11922157, 5403811, 6785775, 13794224, 11958753, 16494451, 12313218,
1297763, 1126021, 345418, 528188, 2114627, 6400133, 8307281, 490653,
8793363, 16336633, 10653219, 2214875, 13551003, 1001246, 397033, 12381376,
5991449, 1443593, 2622811, 7847125, 944151, 13889218, 14686341, 6939782,
1712728, 12902341, 4138467, 13656813, 973555, 4767079, 9100632, 13222220,
11641873, 9082629, 12639233, 11258141, 2146301, 1867442, 12719413, 16679909,
8734589, 1606713, 9501535, 6761395, 6693929, 13647363, 9914313, 15335895,
2021653, 4068909, 2228794, 12603329, 11807792, 12665538, 395494, 3299447,
5119086, 2917420, 10055436, 4831656, 3927888, 14447609, 4329094, 13077467,
11461522, 14594477, 6481991, 8367571, 7156844, 9223013, 6482120, 10542896,
10286402, 11125093, 14144872, 16495825, 1844776, 860068, 9980169, 14877755,
2804551, 8894974, 12849678, 8215338, 15490728, 3843485, 5184218, 7071904,
7703600, 4633458, 11481528, 15295069, 3736219, 14297843, 3787634, 6015173,
14290065, 7290758, 11764335, 3688927, 7991532, 12075598, 606202, 4674522,
13772937, 6515326, 14974617, 3385263, 4587760, 15178512, 7689244, 15015527,
3087738, 3683764, 5107535, 10120404, 6225460, 8588999, 4151219, 9885848,
6691152, 518908, 13918089, 13393004, 13093729, 16338349, 5945377, 15632500,
4230314, 13832167, 12139768, 5361165, 11457892, 3916190, 2387780, 325816,
6621694, 7540927, 5271271, 10565439, 3281837, 11138623, 6663214, 737100,
6864802, 16592415, 14615312, 4342441, 2525512, 16706191, 14258395, 11878990,
1320531, 14696398, 8201398, 16077183, 12155328, 15225360, 6533378, 16390602,
11750387, 4144864, 3744598, 4136761, 1775074, 3787875, 10061327, 3165792,
6921717, 84292, 7420530, 11805441, 6704350, 4234280, 13377633, 6417611,
81563, 11879309, 6692731, 10285066, 5452490, 2848306, 6094584, 6772150,
2899899, 805004, 7273360, 4566720, 13878010, 10871921, 3724097, 11896809,
15586671, 5744620, 13731591, 16250661, 8560290, 8169917, 7059338, 14615241,
3149669, 4383295, 1292178, 7919990, 846550, 896930, 8769114, 11437924,
3854132, 16345157, 2929809, 186157, 8183120, 10860321, 10092509, 7157818,
8817522, 2944051, 4664124, 6791689, 12517547, 12905829, 12435281, 5992485,
2074096, 13062653, 14148480, 10024647, 7455154, 6534752, 5933059, 9930860,
8221561, 2639915, 10098755, 11468155, 8638604, 15770467, 7790866, 11694410,
2868248, 5710862, 15709, 12374346, 5274287, 10913198, 9607083, 2330533,
11262155, 2500209, 10878393, 11834918, 15572289, 15669880, 11713730, 8818293,
15907500, 12427744, 13540318, 5978200, 13640927, 2411696, 16408949, 1331989,
5941655, 3414928, 16619879, 6441500, 15706705, 9881210, 12620326, 12259629,
6605901, 10543825, 9125515, 12001189, 8309409, 2696396, 3070853, 5120614,
11830622, 10490623, 4149060, 7141756, 7297762, 12039919, 4930206, 16095035,
10203610, 12162006, 10028034, 14040149, 1250372, 9943013, 11150309, 1752285,
6641241, 532227, 2891993, 2146459, 4523080, 1843838, 1876388, 12071882,
5253689, 266407, 14770216, 7346541, 9785383, 12662763, 4087061, 5312086,
8667965, 5935475, 214509, 14935237, 12603345, 12069351, 13056011, 3177187,
13886924, 9688141, 5714168, 5238287, 9839924, 6586077, 12908278, 3257673,
7665358, 16208962, 12373914, 14796394, 11098653, 5975276, 14839805, 2522300,
13055068, 4113411, 11984808, 1418893, 6924381, 11314606, 11633137, 13235995,
8277143, 14057346, 5064134, 2097065, 13223254, 12242045, 13059400, 9799866,
4430809, 11327935, 769464, 13938921, 11178479, 5438437, 1550013, 12839250,
727385, 11354068, 3772220, 15394227, 9336140, 11988768, 860366, 14994301,
15440057, 7845075, 46465, 9200550, 14833083, 6980643, 604527, 10080643,
9045195, 4244693, 3844932, 12717539, 1960282, 12786813, 8615113, 6833198,
5522541, 5791657, 15755268, 3994917, 158446, 12203633, 5002730, 10253904,
1809471, 11479213, 9928035, 11072909, 9512807, 11660261, 16127120, 12596061,
7086362, 15820414, 8387982, 14653636, 10912742, 1941253, 11740079, 15457795,
3976572, 10595620, 7217556, 6197451, 7618490, 258825, 4780842, 5534349,
2921202, 6513404, 16229803, 10332843, 3138363, 15681804, 10802604, 13113540,
13757900, 5443555, 3681765, 5063855, 14185653, 14039650, 9644178, 5024611,
8918836, 11231866, 13523137, 2425209, 8636320, 10944802, 3891863, 12961644,
10984042, 9100512, 11218774, 11581954, 8646320, 11234763, 11887145, 4171898,
5109569, 10742219, 4859349, 16381539, 10419813, 5223261, 8955000, 15061357,
1607571, 7136846, 8670269, 11099382, 1451676, 4261185, 12586581, 15531576,
2504976, 7105767, 6413040, 7144290, 16334106, 1741877, 16270583, 7852246,
3119103, 10743199, 4558377, 7878745, 12289371, 3163084, 11735282, 1935864,
5055074, 820851, 5185654, 14442671, 5212885, 2344949, 1892708, 1153520,
9541794, 12306031, 14732248, 6743381, 5920025, 8969603, 8847687, 6622806,
9462942, 12451035, 2336870, 327996, 9713350, 9963027, 11991923, 3562944,
4520396, 7065629, 2905597, 12675100, 10094378, 5011336, 3908274, 3572588,
15618069, 13341879, 9470980, 13327842, 8432408, 6344466, 12241360, 1543979,
12081229, 11363884, 983612, 6025413, 1848571, 14318469, 14906334, 13381442,
3327004, 15286722, 14443922, 9462145, 15828870, 16292084, 128023, 4199307,
12797648, 6169450, 6767468, 8100201, 9756312, 10612295, 2273164, 3350998,
15889011, 3661060, 9395406, 1435793, 5752767, 16441805, 16677778, 6475274,
12909030, 15902971, 3415473, 9004053, 645884, 515610, 8824322, 16574526,
15956463, 13265827, 6333169, 6924814, 1812983, 3392856, 14761092, 4985619,
7893816, 13931135, 14548854, 11444226, 9118923, 1875105, 7285192, 2101733,
7801836, 11517693, 2349183, 5939167, 11937456, 10886500, 13866155, 12947589,
9640186, 5047153, 1901666, 715551, 13790692, 2933460, 11212664, 9563015,
16642428, 16334427, 7140601, 4655671, 15711153, 750565, 15067249, 16737043,
12684416, 15673315, 2341376, 8935324, 3134061, 10483409, 337177, 13018877,
16599994, 7782302, 1977121, 10593779, 9842381, 14330646, 1456639, 3774065,
12844377, 3016177, 8933870, 12263851, 10455534, 1612109, 16302350, 4895080,
12932155, 1905228, 10253063, 4458040, 16024500, 15902756, 16584305, 12528008,
4171461, 14536742, 9219403, 12927168, 1979395, 15257546, 10619265, 1967594,
1467515, 2028519, 2032612, 3707709, 4887462, 2337860, 183801, 2152077,
15066473, 3694942, 8424967, 15508266, 13386596, 6059869, 10531128, 13828874,
7119662, 5064756, 12552069, 5922533, 802911, 5645620, 10781530, 11246590,
9323418, 16275234, 2144845, 10962831, 4925357, 1704524, 9227431, 13641289,
8489002, 1225340, 8659144, 8671408, 13461400, 4992933, 13370774, 8568931,
2412794, 1312411, 12429994, 1025208, 478829, 11399895, 2242158, 2332498,
10717459, 8151843, 5288043, 7235700, 9162569, 14017735, 10412273, 12712138,
11844638, 11163643, 7756823, 9956164, 14078510, 8442139, 2116890, 10881649,
16223710, 8592664, 15408035, 6522496, 1261635, 14685232, 5071601, 10144049,
967751, 7873356, 5595700, 10647000, 15126220, 1237821, 321796, 6173902,
14476409, 1830511, 12766190, 14322080, 8483740, 13438254, 1854079, 6215655,
11575352, 15129118, 16393883, 16560142, 9079559, 11379168, 6198702, 11864074,
2282933, 16547051, 7156233, 15740343, 4809601, 2344447, 10219155, 4977972,
13592880, 184650, 16420038, 3165940, 9418081, 13446140, 179241, 9394692,
6213074, 1752099, 3516715, 16081239, 13222615, 1499877, 9066661, 12702088,
10706447, 7629231, 13016955, 1069166, 1089471, 6809842, 15634321, 1288782,
1183469, 9576844, 14191973, 2814257, 4260748, 5239952, 4277681, 4629271,
8220928, 8766876, 7388663, 13090704, 15838538, 11015909, 7814987, 14448125,
13000849, 15596437, 2104764, 8398024, 15653431, 3695833, 6613072, 13626967,
2665818, 9249819, 4040305, 8029033, 4822667, 3844052, 14708928, 690088
};
THashMap map = new THashMap();
int[] to_remove = new int[]{
9707851, 7941420, 9178562, 2165498, 4160722, 5570057, 1774305, 11340758,
10326974, 8644308
};
for ( int i = 0; i < to_add.length; i++ ) {
Integer obj = new Integer( to_add[i] );
map.put( obj, obj );
}
for ( int i = 0; i < to_remove.length; i++ ) {
Integer obj = new Integer( to_remove[i] );
map.remove( obj );
}
}
public void testIterable() {
Map m = new THashMap();
m.put( "One", Integer.valueOf( 1 ) );
m.put( "Two", Integer.valueOf( 2 ) );
for ( String s : m.keySet() ) {
assertTrue( s.equals( "One" ) || s.equals( "Two" ) );
}
for ( Integer i : m.values() ) {
assertTrue( i.intValue() == 1 || i.intValue() == 2 );
}
}
public void testKeysFunctions() {
int element_count = 10;
String[] keys = new String[element_count];
String[] vals = new String[element_count];
for ( int i = 0; i < element_count; i++ ) {
keys[i] = "Key" + i;
vals[i] = "Vals" + i;
ss_map.put( keys[i], vals[i] );
}
assertEquals( element_count, ss_map.size() );
Collection keys_set = ss_map.keySet();
assertTrue( "should contain " + keys[5] + ", " + ss_map,
keys_set.contains( keys[5] ) );
assertFalse( "invalid remove succeeded " + keys_set,
keys_set.remove( "non-existant" ) );
assertTrue( "remove failed: " + keys_set, keys_set.remove( keys[5] ) );
assertFalse( "key set contains removed item",
keys_set.contains( keys[5] ) );
assertFalse( "map contains removed item" + ss_map,
ss_map.contains( keys[5] ) );
assertFalse( "map contains removed item" + ss_map,
ss_map.containsKey( keys[5] ) );
assertFalse( "cannot remove item not in set",
keys_set.remove( "non-existant" ) );
}
public void testValuesFunctions() {
int element_count = 10;
String[] vals = new String[element_count];
for ( int i = 0; i < element_count; i++ ) {
vals[i] = "Val" + i;
ss_map.put( "Key" + i, vals[i] );
}
assertEquals( element_count, ss_map.size() );
Collection values_set = ss_map.values();
assertTrue( "should contain " + vals[5] + ", " + ss_map,
values_set.contains( vals[5] ) );
Set set = new HashSet();
for ( int i = 0; i < element_count; i++ ) {
vals[i] = "Val" + i;
set.add( vals[i] );
}
assertTrue( "should contain all: " + values_set + ", " + set,
values_set.containsAll( set ) );
set.add( "cause failure" );
assertFalse( "shouldn't contain all: " + values_set,
values_set.containsAll( set ) );
values_set.clear();
assertEquals( "values set size should be 0", 0, values_set.size() );
assertEquals( "map size should be 0", 0, ss_map.size() );
assertTrue( values_set.isEmpty() );
try {
values_set.add( "fail" );
fail( "Expected UnsupportedOperationException" );
}
catch ( UnsupportedOperationException ex ) {
// Expected
}
try {
values_set.addAll( Arrays.asList( "fail" ) );
fail( "Expected UnsupportedOperationException" );
}
catch ( UnsupportedOperationException ex ) {
// Expected
}
}
@SuppressWarnings({"ToArrayCallWithZeroLengthArrayArgument"})
public void testValuesToArray() {
int element_count = 10;
String[] vals = new String[element_count];
for ( int i = 0; i < element_count; i++ ) {
vals[i] = "Val" + i;
ss_map.put( "Key" + i, vals[i] );
}
Collection values_set = ss_map.values();
String[] toarray = values_set.toArray( new String[0] );
Arrays.sort( toarray );
assertEquals( Arrays.asList( vals ), Arrays.asList( toarray ) );
toarray = values_set.toArray( new String[element_count] );
Arrays.sort( toarray );
assertEquals( Arrays.asList( vals ), Arrays.asList( toarray ) );
toarray = values_set.toArray( new String[element_count + 1] );
assertEquals( null, toarray[element_count] );
Arrays.sort( toarray, 0, element_count );
for ( int i = 0; i < element_count; i++ ) {
assertEquals( vals[i], toarray[i] );
}
}
public void testIteratorFunctions() throws Exception {
int element_count = 10;
String[] keys = new String[element_count];
String[] vals = new String[element_count];
for ( int i = 0; i < element_count; i++ ) {
keys[i] = "Key" + i;
vals[i] = "Val" + i;
ss_map.put( keys[i], vals[i] );
}
Iterator> iter = ss_map.entrySet().iterator();
while ( iter.hasNext() ) {
Map.Entry ee = iter.next();
assertTrue( Arrays.asList( keys ).contains( ee.getKey() ) );
assertTrue( Arrays.asList( vals ).contains( ee.getValue() ) );
count++;
}
iter = ss_map.entrySet().iterator();
assertTrue( iter.hasNext() );
Map.Entry ee = iter.next();
assertTrue( "remove on entrySet() returned false",
ss_map.entrySet().remove( ee ) );
assertEquals( element_count - 1, ss_map.size() );
}
@SuppressWarnings({"unchecked"})
public void testEntrySetFunctions() {
int element_count = 10;
String[] keys = new String[element_count];
String[] vals = new String[element_count];
for ( int i = 0; i < element_count; i++ ) {
keys[i] = "Key" + i;
vals[i] = "Val" + i;
ss_map.put( keys[i], vals[i] );
}
Iterator> iter = ss_map.entrySet().iterator();
assertTrue( iter.hasNext() );
Map.Entry ee = iter.next();
assertNotNull( ee.getKey() );
assertNotNull( ee.getValue() );
assertNotNull( ee.getValue() );
assertNotNull( ee.getValue() );
String new_value = "New Value";
String old_value = ee.getValue();
assertEquals( old_value, ee.setValue( new_value ) );
assertFalse( old_value.equals( ee.getValue() ) );
assertFalse( ss_map.values().contains( old_value ) );
assertTrue( ss_map.values().contains( new_value ) );
assertTrue( ss_map.containsValue( new_value ) );
assertFalse( "equal vs. random object incorrect", ee.equals( new Object() ) );
}
// public void testGetOverRemovedObjectBug() {
// Map m = new THashMap(
// new TObjectHashingStrategy() {
// public int computeHashCode(BadHashInteger object) {
// return object.hashCode();
// }
//
// public boolean equals(BadHashInteger o1, BadHashInteger o2) {
// return o1.value == o2.value;
// }
// } );
//
//
// m.put( new BadHashInteger( 1 ), "one" );
// m.put( new BadHashInteger( 2 ), "two" );
//
// m.remove( new BadHashInteger( 1 ) );
//
// assertEquals( 1, m.size() );
//
// // Blow up here?
// assertEquals( "two", m.get( new BadHashInteger( 2 ) ) );
// }
//
// public void testReaddBug() {
// Map m = new THashMap(
// new TObjectHashingStrategy() {
// public int computeHashCode(Integer object) {
// return object.intValue();
// }
//
// public boolean equals(Integer o1, Integer o2) {
// return o1.intValue() == o2.intValue();
// }
// } );
//
// m.put( new Integer( 1 ), "one" );
// assertEquals(1, m.size());
//
// m.remove( new Integer( 1 ) );
// assertEquals(0, m.size());
//
// m.put( new Integer( 1 ), "one" );
// assertEquals(1, m.size());
// }
public void testToString() {
ss_map.put( "One", "1" );
ss_map.put( "Two", "2" );
String to_string = ss_map.toString();
assertTrue( to_string,
to_string.equals( "{One=1, Two=2}" ) || to_string.equals( "{Two=2, One=1}" ) );
}
public void testEntrySetToString() {
Map map = new THashMap();
map.put( "One", "1" );
map.put( "Two", "2" );
String to_string = map.entrySet().toString();
assertTrue( to_string,
to_string.equals( "{One=1, Two=2}" ) || to_string.equals( "{Two=2, One=1}" ) );
}
public void testKeySetToString() {
Map map = new THashMap();
map.put( "One", "1" );
map.put( "Two", "2" );
String to_string = map.keySet().toString();
assertTrue( to_string,
to_string.equals( "{One, Two}" ) || to_string.equals( "{Two, One}" ) );
}
public void testValuesToString() {
Map map = new THashMap();
map.put( "One", "1" );
map.put( "Two", "2" );
String to_string = map.values().toString();
assertTrue( to_string,
to_string.equals( "{1, 2}" ) || to_string.equals( "{2, 1}" ) );
}
/**
* Make sure that REMOVED entries are pruned when doing compaction.
*/
public void testRemovedSlotPruning() {
THashMap map = new THashMap();
map.put( "ONE", "1" );
map.put( "TWO", "2" );
map.put( "THREE", "3" );
// Compact to make sure we're at the internal capacity we want to ultimate be at
map.compact();
// Make sure there are no REMOVED slots initially
for( Object set_entry : map._set ) {
if ( set_entry == TObjectHash.REMOVED ) fail( "Found a REMOVED entry" );
}
map.remove( "TWO" );
map.put( "FOUR", "4" );
// Make sure there is 1 REMOVED slot
int count = 0;
for( Object set_entry : map._set ) {
if ( set_entry == TObjectHash.REMOVED ) count++;
}
assertEquals( 1, count );
map.compact();
// Make sure there are no REMOVED slots
for( Object set_entry : map._set ) {
if ( set_entry == TObjectHash.REMOVED ) {
fail( "Found a REMOVED entry after compaction" );
}
}
}
/**
* Make sure that REMOVED entries are pruned when doing compaction.
*/
public void testFreeSlotCounterConsistency() {
THashMap map = new THashMap();
HashTestKit.checkFreeSlotCount( map, map._set, TObjectHash.FREE );
map.put( "ONE", "1" );
map.put( "TWO", "2" );
map.put( "THREE", "3" );
HashTestKit.checkFreeSlotCount( map, map._set, TObjectHash.FREE );
// Compact to make sure we're at the internal capacity we want to ultimate be at
map.compact();
HashTestKit.checkFreeSlotCount( map, map._set, TObjectHash.FREE );
map.remove( "TWO" );
map.put( "FOUR", "4" );
HashTestKit.checkFreeSlotCount( map, map._set, TObjectHash.FREE );
map.compact();
HashTestKit.checkFreeSlotCount( map, map._set, TObjectHash.FREE );
}
// Test for issue 3159432
public void testEntrySetRemove() {
THashMap map = new THashMap();
map.put( "ONE", "1" );
map.put( "TWO", "2" );
map.put( "THREE", "3" );
Set> set = map.entrySet();
set.remove( null );
//noinspection SuspiciousMethodCalls
set.remove( "Blargh" );
}
public void testNullKeyHandling() {
THashMap map = new THashMap();
map.put( null, "My null key" );
for( int i = 0; i < 100; i++ ) {
map.put( String.valueOf( i ), String.valueOf( i ) );
}
assertEquals( "My null key", map.get( null ) );
map.put( null, "My new null key" );
map.compact();
for( int i = 100; i < 200; i++ ) {
map.put( String.valueOf( i ), String.valueOf( i ) );
}
assertEquals( "My new null key", map.get( null ) );
for( int i = 0; i < 200; i++ ) {
assertEquals( String.valueOf( i ), map.get( String.valueOf( i ) ) );
}
}
} // THashMapTests
© 2015 - 2024 Weber Informatics LLC | Privacy Policy