public void TestLMoveToSecond()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(1, 11);
d.Add(k1, 1);
HashTableTester k2 = new HashTableTester(4, 44);
d.Add(k2, 4);
// Construct a key-value pair enumerator, a key enumerator, and a value enumerator.
// Call MoveNext once on the key-value pair enumerator, and twice on the other two.
IEnumerator <KeyValuePair <HashTableTester, int> > kvpEnumerator = d.GetEnumerator();
kvpEnumerator.MoveNext();
IEnumerator <HashTableTester> keyEnumerator = d.Keys.GetEnumerator();
keyEnumerator.MoveNext();
keyEnumerator.MoveNext();
IEnumerator <int> valueEnumerator = d.Values.GetEnumerator();
valueEnumerator.MoveNext();
valueEnumerator.MoveNext();
Assert.Multiple(() =>
{
Assert.That(kvpEnumerator.MoveNext(), Is.True);
Assert.That(kvpEnumerator.Current, Is.EqualTo(new KeyValuePair <HashTableTester, int>(k2, 4)));
Assert.That(keyEnumerator.Current, Is.EqualTo(k2));
Assert.That(valueEnumerator.Current, Is.EqualTo(4));
});
}
public void TestDAddThreeLookUpAll()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(700, 0);
HashTableTester k2 = new HashTableTester(700, 1);
HashTableTester k3 = new HashTableTester(700, 2);
d[k1] = 1;
d.Add(k2, 2);
d[k3] = 3;
List <int> list = new List <int>();
int v;
// Look up each key, and add its associated value to list
d.TryGetValue(k1, out v);
list.Add(v);
list.Add(d[k2]);
d.TryGetValue(k3, out v);
list.Add(v);
Assert.Multiple(() =>
{
Assert.That(list, Is.Ordered.And.EquivalentTo(new int[] { 1, 2, 3 })); // Checks the results of the lookups
Assert.That(k1.EqualsCount, Is.EqualTo(5));
});
}
public void TestCAddTwoLookUpFirstWithIndexer()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000);
HashTableTester k2 = new HashTableTester(1025);
d.Add(k1, "first");
d.Add(k2, "second");
Assert.That(d[k1], Is.EqualTo("first"));
}
public void TestCAddTwoContainsKeySecond()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(9998, 1);
HashTableTester k2 = new HashTableTester(10023, 10);
d.Add(k1, "first");
d.Add(k2, "second");
Assert.That(d.ContainsKey(k2), Is.True);
}
public void TestCSetTwoGetSecond()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(9998, 1);
HashTableTester k2 = new HashTableTester(10023, 10);
d[k1] = "first";
d[k2] = "second";
Assert.That(d[k2], Is.EqualTo("second"));
}
public void TestEAddTwoRemoveSecond()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(23, 2);
HashTableTester k2 = new HashTableTester(33, 3);
d.Add(k1, 2);
d.Add(k2, 3);
d.Remove(k2);
Assert.That(d.ContainsKey(k1));
}
public void TestDTwoInstancesSameLocation()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(100, true);
HashTableTester k2 = new HashTableTester(105, true);
d[k1] = 7;
// Because k1 and k2 are constructed to be equal to all other instances of HashTableTester, the dictionary
// should find k2 if it maps to the same array location as k1.
Assert.That(d.TryGetValue(k2, out int v), Is.True);
}
public void TestCAddTwoWithIndexerTryGetValueFSecond()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000);
HashTableTester k2 = new HashTableTester(1025);
d[k1] = "first";
d[k2] = "second";
d.TryGetValue(k2, out string v);
Assert.That(v, Is.EqualTo("second"));
}
public void TestBAddOneContainsKey()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(10000, 25); // Hash code is 10000, Data is 25
d.Add(k, "value");
Assert.Multiple(() =>
{
Assert.That(d.ContainsKey(k), Is.True);
Assert.That(k.GetHashCodeCount, Is.EqualTo(2)); // GetHashCode should be called once on Add, once on ContainsKey
});
}
/// <summary>
/// Determines whether the given object is equal to this instance.
/// </summary>
/// <param name="obj">The object to compare to.</param>
/// <returns>Whether obj is equal to this instance.</returns>
public override bool Equals(object obj)
{
if (obj is HashTableTester)
{
HashTableTester x = (HashTableTester)obj;
return(x == this);
}
else
{
return(false);
}
}
public void TestBSetOne()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(27, 30); // Hash code is 27.
d[k] = "value"; // Hash code is 27.
Assert.Multiple(() =>
{
Assert.That(d.HashTable[2], Is.EqualTo(0)); // Location 2 should refer to the first cell in the pool.
Assert.That(k.GetHashCodeCount, Is.EqualTo(1)); // k's GetHashCode method should have been called only once.
});
}
public void TestETwoInstancesSameLocation()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(100);
HashTableTester k2 = new HashTableTester(125, true);
d.Add(k1, 7);
int v;
// Because k2 is equal to any key, the dictionary
// should find k2 if it maps to the same array location as k1.
Assert.That(d.TryGetValue(k2, out v), Is.True);
}
public void TestBSetOneGet()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(100000, 5); // Hash code is 100000, Data is 5
d[k] = "value";
string v = d[k];
Assert.Multiple(() =>
{
Assert.That(v, Is.EqualTo("value")); // The result of the lookup
Assert.That(k.GetHashCodeCount, Is.EqualTo(2)); // GetHashCode should be called once on Set, once on Get
});
}
public void TestBAddOneLookItUp()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(100000);
d.Add(k, "value");
string v;
bool b = d.TryGetValue(k, out v);
Assert.Multiple(() =>
{
Assert.That(b, Is.True);
Assert.That(v, Is.EqualTo("value"));
});
}
public void TestCAddTwoWithIndexerTryGetValueFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000);
HashTableTester k2 = new HashTableTester(1025);
d[k1] = "first";
d[k2] = "second";
d.TryGetValue(k1, out string v);
Assert.Multiple(() =>
{
Assert.That(d.Count, Is.EqualTo(2));
Assert.That(v, Is.EqualTo("first"));
});
}
public void TestBAddOneTryGetValue()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(100000, 5); // Hash code is 100000, Data is 5
d.Add(k, "value");
string v;
bool b = d.TryGetValue(k, out v);
Assert.Multiple(() =>
{
Assert.That(b, Is.True); // TryGetValue returned true
Assert.That(v, Is.EqualTo("value")); // The out parameter was set to "value"
Assert.That(k.GetHashCodeCount, Is.EqualTo(2)); // GetHashCode should be called once on Add, once on TryGetValue
});
}
public void TestEAddTwoRemoveFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(44, 1);
HashTableTester k2 = new HashTableTester(33, 2);
d.Add(k1, "value1");
d.Add(k2, "value2");
Assert.Multiple(() =>
{
Assert.That(d.Remove(k1), Is.True);
Assert.That(d.ContainsKey(k1), Is.False);
Assert.That(d.Count, Is.EqualTo(1));
Assert.That(d.RemovedList, Is.EqualTo(0));
});
}
public void TestCAddTwoContainsKeyFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000, 23);
HashTableTester k2 = new HashTableTester(1025, 25);
d.Add(k1, "first");
d.Add(k2, "second");
Assert.Multiple(() =>
{
Assert.That(d.ContainsKey(k1), Is.True);
Assert.That(k1.GetHashCodeCount, Is.EqualTo(2));
Assert.That(k1.EqualsCount, Is.EqualTo(1)); // k1 should only be involved in one equality test.
Assert.That(k2.EqualsCount, Is.EqualTo(0)); // k2 should not be involved in any equality tests.
});
}
public void TestCSetTwoGetFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000, 23);
HashTableTester k2 = new HashTableTester(1025, 25);
d[k1] = "first";
d[k2] = "second";
Assert.Multiple(() =>
{
Assert.That(d[k1], Is.EqualTo("first"));
Assert.That(k1.GetHashCodeCount, Is.EqualTo(2));
Assert.That(k1.EqualsCount, Is.EqualTo(1)); // k1 should only be involved in one equality test.
Assert.That(k2.EqualsCount, Is.EqualTo(0)); // k2 should not be involved in any equality tests.
});
}
public void TestCAddTwoLookUpFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000);
HashTableTester k2 = new HashTableTester(1023);
d.Add(k1, "first");
d.Add(k2, "second");
string v;
bool b = d.TryGetValue(k1, out v);
Assert.Multiple(() =>
{
Assert.That(b, Is.True);
Assert.That(v, Is.EqualTo("first"));
});
}
public void TestJCurrentKeyAtStart()
{
Dictionary <HashTableTester, double> d = new Dictionary <HashTableTester, double>();
d.Add(new HashTableTester(0, 1), 1.1);
IEnumerator <HashTableTester> enumerator = d.Keys.GetEnumerator();
Exception e = null;
try
{
HashTableTester p = enumerator.Current; // Should throw an InvalidOperationException
}
catch (Exception ex)
{
e = ex; // Sets e to any exception that was thrown.
}
Assert.That(e, Is.Not.Null.And.TypeOf(typeof(InvalidOperationException)));
}
public void TestEAddThreeRemoveSecond()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(22, 2);
d.Add(k1, 2);
HashTableTester k2 = new HashTableTester(32, 3);
d.Add(k2, 3);
HashTableTester k3 = new HashTableTester(12, 1);
d.Add(k3, 1);
d.Remove(k2);
Assert.Multiple(() =>
{
Assert.That(d[k1], Is.EqualTo(2));
Assert.That(d.ContainsKey(k2), Is.False);
Assert.That(d[k3], Is.EqualTo(1));
});
}
public void TestCAddTwoTryGetValueFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k1 = new HashTableTester(1000, 23);
HashTableTester k2 = new HashTableTester(1025, 25);
d.Add(k1, "first");
d.Add(k2, "second");
string v;
bool b = d.TryGetValue(k1, out v);
Assert.Multiple(() =>
{
Assert.That(b, Is.True); // TryGetValue returned true.
Assert.That(v, Is.EqualTo("first")); // The out parameter was set to "first"
Assert.That(k1.GetHashCodeCount, Is.EqualTo(2));
Assert.That(k1.EqualsCount, Is.EqualTo(1)); // k1 should only be involved in one equality test.
Assert.That(k2.EqualsCount, Is.EqualTo(0)); // k2 should not be involved in any equality tests.
});
}
public void TestDAddThreeLookUpAll()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
HashTableTester k1 = new HashTableTester(700);
HashTableTester k2 = new HashTableTester(723);
HashTableTester k3 = new HashTableTester(746);
d.Add(k1, 1);
d.Add(k2, 2);
d.Add(k3, 3);
List <int> list = new List <int>();
int v;
d.TryGetValue(k1, out v);
list.Add(v);
d.TryGetValue(k2, out v);
list.Add(v);
d.TryGetValue(k3, out v);
list.Add(v);
Assert.That(list, Is.Ordered.And.EquivalentTo(new int[] { 1, 2, 3 }));
}
public void TestKMoveToFirst()
{
Dictionary <HashTableTester, string> d = new Dictionary <HashTableTester, string>();
HashTableTester k = new HashTableTester(0, 1);
d.Add(k, "first");
IEnumerator <KeyValuePair <HashTableTester, string> > kvpEnumerator = d.GetEnumerator();
IEnumerator <HashTableTester> keyEnumerator = d.Keys.GetEnumerator();
IEnumerator <string> valueEnumerator = d.Values.GetEnumerator();
StringBuilder sb = new StringBuilder();
sb.Append(kvpEnumerator.MoveNext()).Append(';');
sb.Append(keyEnumerator.MoveNext()).Append(';');
sb.Append(valueEnumerator.MoveNext()).Append(';');
Assert.Multiple(() =>
{
Assert.That(sb.ToString(), Is.EqualTo("True;True;True;")); // MoveNext should return true for each enumerator.
Assert.That(kvpEnumerator.Current, Is.EqualTo(new KeyValuePair <HashTableTester, string>(k, "first")));
Assert.That(keyEnumerator.Current, Is.EqualTo(k));
Assert.That(valueEnumerator.Current, Is.EqualTo("first"));
});
}
public void TestIDoubleRehashToSameList()
{
Dictionary <HashTableTester, int> d = new Dictionary <HashTableTester, int>();
List <HashTableTester> elements = new List <HashTableTester>();
for (int i = 100; i < 376; i += 23)
{
HashTableTester k = new HashTableTester(i, i);
d.Add(k, i); // Adds 12 keys that should end up in the same list after rehashing twice
elements.Add(k);
}
int sum = 0;
foreach (HashTableTester k in elements)
{
if (d.ContainsKey(k))
{
sum++;
}
}
Assert.That(sum, Is.EqualTo(12)); // All 12 keys were found.
}
