public void TestRehash()
{
// This map should rehash on adding the ninth element.
HashMap <MyKey, Object> hm = new HashMap <MyKey, Object>(10, 0.5f);
// Ordered set of keys.
MyKey[] keyOrder = new MyKey[9];
for (int i = 0; i < keyOrder.Length; i++)
{
keyOrder[i] = new MyKey();
}
// Store eight elements
for (int i = 0; i < 8; i++)
{
hm.Put(keyOrder[i], i);
}
// Check expected ordering (inverse of adding order)
MyKey[] returnedKeys = hm.KeySet().ToArray();
for (int i = 0; i < 8; i++)
{
Assert.AreSame(keyOrder[i], returnedKeys[7 - i]);
}
// The Next Put causes a rehash
hm.Put(keyOrder[8], 8);
// Check expected new ordering (adding order)
returnedKeys = hm.KeySet().ToArray();
for (int i = 0; i < 9; i++)
{
Assert.AreSame(keyOrder[i], returnedKeys[i]);
}
}
public void TestKeySet()
{
Set <Object> s = hm.KeySet();
Assert.IsTrue(s.Size() == hm.Size(), "Returned set of incorrect Size()");
for (int i = 0; i < objArray.Length; i++)
{
Assert.IsTrue(s.Contains(objArray[i].ToString()), "Returned set does not contain all keys");
}
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(null, "test");
Assert.IsTrue(m.KeySet().Contains(null), "Assert.Failed with null key");
Assert.IsNull(m.KeySet().Iterator().Next(), "Assert.Failed with null key");
Map <Object, Object> map = new HashMap <Object, Object>(101);
map.Put(1, "1");
map.Put(102, "102");
map.Put(203, "203");
Iterator <Object> it = map.KeySet().Iterator();
Object remove1 = it.Next();
Assert.IsTrue(it.HasNext);
it.Remove();
Object remove2 = (Int32)it.Next();
it.Remove();
ArrayList <Object> list = new ArrayList <Object>(Arrays.AsList(new Object[] { 1, 102, 203 }));
list.Remove(remove1);
list.Remove(remove2);
Assert.IsTrue(it.Next().Equals(list.Get(0)), "Wrong result");
Assert.AreEqual(1, map.Size(), "Wrong Size");
Assert.IsTrue(map.KeySet().Iterator().Next().Equals(list.Get(0)), "Wrong contents");
Map <Object, Object> map2 = new HashMap <Object, Object>(101);
map2.Put(1, "1");
map2.Put(4, "4");
Iterator <Object> it2 = map2.KeySet().Iterator();
Object remove3 = it2.Next();
Object Next;
if ((int)remove3 == 1)
{
Next = 4;
}
else
{
Next = 1;
}
Assert.IsTrue(it2.HasNext);
it2.Remove();
Assert.IsTrue(it2.Next().Equals(Next), "Wrong result 2");
Assert.AreEqual(1, map2.Size(), "Wrong Size 2");
Assert.IsTrue(map2.KeySet().Iterator().Next().Equals(Next), "Wrong contents 2");
}
public void SetUp()
{
hm = new HashMap <object, Object>();
for (int i = 0; i < objArray.Length; i++)
{
hm.Put(objArray2[i], objArray[i]);
}
hm.Put("test", null);
hm.Put(null, "test");
}
public void TestNullsOnViews()
{
Map <String, String> nullHostile = new HashMap <String, String>();
nullHostile.Put("a", "apple");
TestNullsOnView(nullHostile.EntrySet());
nullHostile.Put("a", "apple");
TestNullsOnView(nullHostile.KeySet());
nullHostile.Put("a", "apple");
TestNullsOnView(nullHostile.Values());
}
public void TestEqualsWithNullValues()
{
Map <String, String> a = new HashMap <String, String>();
a.Put("a", null);
a.Put("b", null);
Map <String, String> b = new HashMap <String, String>();
a.Put("c", "cat");
a.Put("d", "dog");
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(b.Equals(a));
}
public void TestMapEntryHashCode()
{
HashMap <Object, Object> map = new HashMap <Object, Object>(10);
Object key = 1;
Object val = 2;
map.Put(key, val);
int expected = key.GetHashCode() ^ val.GetHashCode();
Assert.AreEqual(expected, map.GetHashCode());
key = 4;
val = 8;
map.Put(key, val);
expected += key.GetHashCode() ^ val.GetHashCode();
Assert.AreEqual(expected, map.GetHashCode());
}
public void TestConstructorMap()
{
Map <Object, Object> myMap = new LinkedHashMap <Object, Object>();
for (int counter = 0; counter < hmSize; counter++)
{
myMap.Put(objArray2[counter], objArray[counter]);
}
HashMap <Object, Object> hm2 = new HashMap <Object, Object>(myMap);
for (int counter = 0; counter < hmSize; counter++)
{
Assert.IsTrue(hm.Get(objArray2[counter]) == hm2.Get(objArray2[counter]), "Assert.Failed to construct correct HashMap");
}
try
{
Map <Object, Object> mockMap = new MockMap();
hm = new HashMap <Object, Object>(mockMap);
Assert.Fail("Should throw NullReferenceException");
}
catch (NullReferenceException)
{
//empty
}
HashMap <Object, Object> map = new HashMap <Object, Object>();
map.Put("a", "a");
SubMap <Object, Object> map2 = new SubMap <Object, Object>(map);
Assert.IsTrue(map2.ContainsKey("a"));
Assert.IsTrue(map2.ContainsValue("a"));
}
public void TestValues()
{
Collection <Object> c = hm.Values();
Assert.IsTrue(c.Size() == hm.Size(), "Returned collection of incorrect Size()");
for (int i = 0; i < objArray.Length; i++)
{
Assert.IsTrue(c.Contains(objArray[i]), "Returned collection does not contain all keys");
}
HashMap <Object, Object> myHashMap = new HashMap <Object, Object>();
for (int i = 0; i < 100; i++)
{
myHashMap.Put(objArray2[i], objArray[i]);
}
Collection <Object> values = myHashMap.Values();
// new Support_UnmodifiableCollectionTest(
// "Test Returned Collection From HashMap.Values()", values)
// .runTest();
values.Remove(0);
Assert.IsTrue(!myHashMap.ContainsValue(0),
"Removing from the values collection should Remove from the original map");
}
public void TestRemove()
{
int Size = hm.Size();
Object y = 9;
Object x = hm.Remove(y.ToString());
Assert.IsTrue(x.Equals(9), "Remove returned incorrect value");
Assert.IsNull(hm.Get(9), "Assert.Failed to Remove given key");
Assert.IsTrue(hm.Size() == (Size - 1), "Assert.Failed to decrement Size");
Assert.IsNull(hm.Remove("LCLCLC"), "Remove of non-existent key returned non-null");
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(null, "test");
Assert.IsNull(m.Remove(0), "Assert.Failed with same hash as null");
Assert.AreEqual("test", m.Remove(null), "Assert.Failed with null key");
HashMap <Object, Object> map = new HashMap <Object, Object>();
for (int i = 0; i < 32768; i++)
{
map.Put(i, "const");
}
Object[] values = new Object[32768];
for (int i = 0; i < 32768; i++)
{
values[i] = new Object();
map.Put(i, values[i]);
}
for (int i = 32767; i >= 0; i--)
{
Assert.AreEqual(values[i], map.Remove(i), "Assert.Failed to Remove same value");
}
// Ensure keys with identical hashcode are Removed properly
map = new HashMap <Object, Object>();
for (int i = -32767; i < 32768; i++)
{
map.Put(i, "foobar");
}
// Remove non equal object with same hashcode
Assert.IsNull(map.Remove(new MyKey()));
Assert.AreEqual("foobar", map.Get(0));
map.Remove(0);
Assert.IsNull(map.Get(0));
}
public void TestPutAllLMap()
{
Map <Object, Object> ht = new HashMap <Object, Object>();
Map <Object, Object> amt = new AMT();
ht.Put("this", "that");
amt.PutAll(ht);
Assert.AreEqual(amt, ht, "Should be equal");
}
public void TestToString()
{
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(m, m);
String result = m.ToString();
Assert.IsTrue(result.IndexOf("(this") > -1, "should contain self ref");
}
public void TestContainsKey()
{
Assert.IsTrue(hm.ContainsKey(876.ToString()), "Returned false for valid key");
Assert.IsTrue(!hm.ContainsKey("KKDKDKD"), "Returned true for invalid key");
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(null, "test");
Assert.IsTrue(m.ContainsKey(null), "Assert.Failed with null key");
Assert.IsTrue(!m.ContainsKey(0), "Assert.Failed with missing key matching null hash");
}
public void TestConstructorOfMap()
{
Map <Object, Object> myMap = new HashMap <Object, Object>();
for (int counter = 0; counter < hmSize; counter++)
{
myMap.Put(objArray2[counter], objArray[counter]);
}
LinkedHashMap <Object, Object> hm2 = new LinkedHashMap <Object, Object>(myMap);
for (int counter = 0; counter < hmSize; counter++)
{
Assert.IsTrue(hm.Get(objArray2[counter]) == hm2.Get(objArray2[counter]),
"Failed to construct correct LinkedHashMap");
}
}
public void TestEntrySet2()
{
HashMap <Object, Object> map = new HashMap <Object, Object>();
map.Put(1, "ONE");
Set <Entry <Object, Object> > EntrySet = map.EntrySet();
Iterator <Entry <Object, Object> > e = EntrySet.Iterator();
Object real = e.Next();
Entry <Object, Object> copyEntry = new MockEntry();
Assert.AreEqual(real, copyEntry);
Assert.IsTrue(EntrySet.Contains(copyEntry));
EntrySet.Remove(copyEntry);
Assert.IsFalse(EntrySet.Contains(copyEntry));
}
public void TestClone()
{
HashMap <Object, Object> hm2 = (HashMap <Object, Object>)hm.Clone();
Assert.IsTrue(hm2 != hm, "Clone answered equivalent HashMap");
for (int counter = 0; counter < hmSize; counter++)
{
Assert.IsTrue(hm.Get(objArray2[counter]) == hm2.Get(objArray2[counter]), "Clone answered unequal HashMap");
}
HashMap <Object, Object> map = new HashMap <Object, Object>();
map.Put("key", "value");
// get the KeySet() and Values() on the original Map
Set <Object> keys = map.KeySet();
Collection <Object> values = map.Values();
Assert.AreEqual("value", values.Iterator().Next(), "Values() does not work");
Assert.AreEqual("key", keys.Iterator().Next(), "KeySet() does not work");
AbstractMap <Object, Object> map2 = (AbstractMap <Object, Object>)map.Clone();
map2.Put("key", "value2");
Collection <Object> values2 = map2.Values();
Assert.IsTrue(values2 != values, "Values() is identical");
// Values() and KeySet() on the Cloned() map should be different
Assert.AreEqual("value2", values2.Iterator().Next(), "Values() was not Cloned");
map2.Clear();
map2.Put("key2", "value3");
Set <Object> key2 = map2.KeySet();
Assert.IsTrue(key2 != keys, "KeySet() is identical");
Assert.AreEqual("key2", key2.Iterator().Next(), "KeySet() was not Cloned");
HashMap <Object, Object> hashmap = new HashMap <Object, Object>();
MockClonable mock = new MockClonable(1);
hashmap.Put(1, mock);
Assert.AreEqual(1, ((MockClonable)hashmap.Get(1)).i);
HashMap <Object, Object> hm3 = (HashMap <Object, Object>)hashmap.Clone();
Assert.AreEqual(1, ((MockClonable)hm3.Get(1)).i);
mock.i = 0;
Assert.AreEqual(0, ((MockClonable)hashmap.Get(1)).i);
Assert.AreEqual(0, ((MockClonable)hm3.Get(1)).i);
}
public void TestConstructorIF()
{
HashMap <Object, Object> hm2 = new HashMap <Object, Object>(5, (float)0.5);
Assert.AreEqual(0, hm2.Size(), "Created incorrect HashMap");
try
{
new HashMap <Object, Object>(0, 0);
}
catch (ArgumentException)
{
return;
}
Assert.Fail("Assert.Failed to throw ArgumentException for initial load factor <= 0");
HashMap <Object, Object> empty = new HashMap <Object, Object>(0, 0.75f);
Assert.IsNull(empty.Get("nothing"), "Empty hashtable access");
empty.Put("something", "here");
Assert.IsTrue(empty.Get("something").Equals("here"), "cannot get element");
}
public void TestClear()
{
// normal Clear()
AbstractMap <Object, Object> map = new HashMap <Object, Object>();
map.Put(1, 1);
map.Clear();
Assert.IsTrue(map.IsEmpty());
// Special entrySet return a Set with no Clear method.
AbstractMap <Object, Object> myMap = new MocAbstractMap <Object, Object>();
try
{
myMap.Clear();
Assert.Fail("Should throw NotSupportedException");
}
catch (NotSupportedException)
{
}
}
public void TestRemoveObject()
{
Object key = new Object();
Object val = new Object();
AbstractMap <Object, Object> map1 = new HashMap <Object, Object>(0);
map1.Put("key", val);
Assert.AreSame(map1.Remove("key"), val, "HashMap(0)");
AbstractMap <Object, Object> map5 = new LinkedHashMap <Object, Object>(122);
map5.Put(key, val);
Assert.AreSame(map5.Remove(key), val, "LinkedHashMap");
AbstractMap <Object, Object> aSpecialMap = new MyMap();
aSpecialMap.Put(specialKey, specialValue);
Object valueOut = aSpecialMap.Remove(specialKey);
Assert.AreSame(valueOut, specialValue, "MyMap");
}
public void TestClear()
{
hm.Clear();
Assert.AreEqual(0, hm.Size(), "Clear Assert.Failed to reset Size");
for (int i = 0; i < hmSize; i++)
{
Assert.IsNull(hm.Get(objArray2[i]), "Assert.Failed to Clear all elements");
}
// Check Clear on a large loaded map of Int32 keys
HashMap <Object, String> map = new HashMap <Object, String>();
for (int i = -32767; i < 32768; i++)
{
map.Put(i, "foobar");
}
map.Clear();
Assert.AreEqual(0, hm.Size(), "Assert.Failed to reset Size on large integer map");
for (int i = -32767; i < 32768; i++)
{
Assert.IsNull(map.Get(i), "Assert.Failed to Clear integer map values");
}
}
public void TestGet()
{
Assert.IsNull(hm.Get("T"), "Get returned non-null for non existent key");
hm.Put("T", "HELLO");
Assert.AreEqual("HELLO", hm.Get("T"), "Get returned incorrect value for existing key");
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(null, "test");
Assert.AreEqual("test", m.Get(null), "Assert.Failed with null key");
Assert.IsNull(m.Get(0), "Assert.Failed with missing key matching null hash");
ReusableKey k = new ReusableKey();
HashMap <Object, Object> map = new HashMap <Object, Object>();
k.Key = 1;
map.Put(k, "value1");
k.Key = 18;
Assert.IsNull(map.Get(k));
k.Key = 17;
Assert.IsNull(map.Get(k));
}
/// <summary>
/// Adds the specified object to this HashSet if not already present.
/// </summary>
public override bool Add(E obj)
{
return(backingMap.Put(obj, this) == null);
}
public void TestPut2()
{
hm.Put("KEY", "VALUE");
Assert.AreEqual("VALUE", hm.Get("KEY"), "Assert.Failed to install key/value pair");
HashMap <Object, Object> m = new HashMap <Object, Object>();
m.Put(0, "short");
m.Put(null, "test");
m.Put(0, "int");
Assert.AreEqual("int", m.Get(0), "Assert.Failed adding to bucket containing null");
Assert.AreEqual("int", m.Get(0), "Assert.Failed adding to bucket containing null2");
// Check my actual key instance is returned
HashMap <Object, String> map = new HashMap <Object, String>();
for (int i = -32767; i < 32768; i++)
{
map.Put(i, "foobar");
}
Object myKey = 0;
// Put a new value at the old key position
map.Put(myKey, "myValue");
Assert.IsTrue(map.ContainsKey(myKey));
Assert.AreEqual("myValue", map.Get(myKey));
bool found = false;
for (Iterator <Object> itr = map.KeySet().Iterator(); itr.HasNext;)
{
Object key = itr.Next();
if (found = key == myKey)
{
break;
}
}
Assert.IsFalse(found, "Should not find new key instance in hashmap");
// Add a new key instance and check it is returned
Assert.IsNotNull(map.Remove(myKey));
map.Put(myKey, "myValue");
Assert.IsTrue(map.ContainsKey(myKey));
Assert.AreEqual(map.Get(myKey), "myValue");
for (Iterator <Object> itr = map.KeySet().Iterator(); itr.HasNext;)
{
Object key = itr.Next();
if (found = key == myKey)
{
break;
}
}
Assert.IsTrue(found, "Did not find new key instance in hashmap");
// Ensure keys with identical hashcode are stored separately
HashMap <Object, Object> objmap = new HashMap <Object, Object>();
for (int i = 0; i < 32768; i++)
{
objmap.Put(i, "foobar");
}
// Put non-equal object with same hashcode
MyKey aKey = new MyKey();
Assert.IsNull(objmap.Put(aKey, "value"));
Assert.IsNull(objmap.Remove(new MyKey()));
Assert.AreEqual(objmap.Get(0), "foobar");
Assert.AreEqual(objmap.Get(aKey), "value");
}
