public void CrashRmv_gcAdd_NotSupported()
{
var rm = new RankedMap <string, int>();
var gc = (ICollection <int>)rm.Values;
gc.Add(9);
}
public void CrashRm_Remove_ArgumentNull()
{
var rm = new RankedMap <string, int> {
{ "apple", 4 }
};
bool isRemoved = rm.Remove((string)null);
}
public void UnitRm_pcRemovePair()
{
var rm = new RankedMap <string, int>();
var pc = (ICollection <KeyValuePair <string, int> >)rm;
var pair0 = new KeyValuePair <string, int> (null, 0);
var pair1 = new KeyValuePair <string, int> ("ten", 10);
var pair2 = new KeyValuePair <string, int> ("ten", 100);
var pair3 = new KeyValuePair <string, int> ("twenty", 20);
pc.Add(pair0);
pc.Add(pair1);
pc.Add(pair3);
Assert.AreEqual(3, rm.Count);
bool isRemoved = pc.Remove(pair0);
Assert.IsTrue(isRemoved);
Assert.AreEqual(2, rm.Count);
isRemoved = pc.Remove(pair0);
Assert.IsFalse(isRemoved);
Assert.AreEqual(2, rm.Count);
isRemoved = pc.Remove(pair2);
Assert.AreEqual(2, rm.Count);
isRemoved = pc.Remove(pair1);
Assert.IsTrue(isRemoved);
Assert.AreEqual(1, rm.Count);
}
public void CrashRm_CopyTo1_ArgumentOutOfRange()
{
var rm = new RankedMap <int, int>();
var target = new KeyValuePair <int, int> [iVals1.Length];
rm.CopyTo(target, -1);
}
public void CrashRm_ocCopyTo_ArgumentNull()
{
var rm = new RankedMap <int, int>();
var oc = (ICollection)rm;
oc.CopyTo(null, 0);
}
public void UnitRm_ocSyncRoot()
{
var rm = new RankedMap <int, int>();
var oc = (ICollection)rm;
Assert.IsFalse(oc.SyncRoot.GetType().IsValueType);
}
public void UnitRm_pcContainsA()
{
var rm = new RankedMap <string, int> {
Capacity = 4
};
var pc = (ICollection <KeyValuePair <string, int> >)rm;
var nullKv = new KeyValuePair <string, int> (null, 0);
var zedKv = new KeyValuePair <string, int> ("z", 0);
foreach (var kv in greek)
{
pc.Add(kv);
}
foreach (var kv in greek)
{
Assert.IsTrue(pc.Contains(kv));
}
Assert.IsFalse(pc.Contains(zedKv));
Assert.IsFalse(pc.Contains(nullKv));
pc.Add(nullKv);
Assert.IsTrue(pc.Contains(nullKv));
pc.Add(new KeyValuePair <string, int> ("alpha", 0));
Assert.IsTrue(pc.Contains(new KeyValuePair <string, int> ("alpha", 0)));
Assert.IsFalse(pc.Contains(new KeyValuePair <string, int> ("alpha", 99)));
}
public void UnitRm_RemoveWherePair()
{
var rm = new RankedMap <int, int> {
Capacity = 6
};
for (int ix = 0; ix < 110; ++ix)
{
rm.Add(ix, -ix);
}
int r1 = rm.RemoveWhereElement(IsPairLeN100);
Assert.AreEqual(10, r1);
Assert.AreEqual(100, rm.Count);
int c0 = rm.Count;
int r2 = rm.RemoveWhereElement(IsPairEven);
Assert.AreEqual(50, r2);
foreach (int v2 in rm.Values)
{
Assert.IsTrue(v2 % 2 != 0);
}
int r2b = rm.RemoveWhereElement(IsPairEven);
Assert.AreEqual(0, r2b);
int r3 = rm.RemoveWhereElement(IsPairAlways);
Assert.AreEqual(50, r3);
Assert.AreEqual(0, rm.Count);
}
public void UnitRm_ElementsBetweenA()
{
var rm = new RankedMap <string, int>();
var pc = (ICollection <KeyValuePair <string, int> >)rm;
rm.Add("Alpha", 1);
rm.Add("Beta", 2);
rm.Add("Omega", 24);
int actual1 = 0;
foreach (var kv in rm.ElementsBetween(null, "C"))
{
++actual1;
}
pc.Add(new KeyValuePair <string, int> (null, 0));
int actual2 = 0;
foreach (var kv in rm.ElementsBetween(null, "C"))
{
++actual2;
}
Assert.AreEqual(2, actual1);
Assert.AreEqual(3, actual2);
}
public void UnitRmv_EtorCurrentHotUpdate()
{
var rm1 = new RankedMap <int, int> {
{ 3, -3 }
};
var etor1 = rm1.Values.GetEnumerator();
Assert.AreEqual(default(int), etor1.Current);
bool ok1 = etor1.MoveNext();
Assert.AreEqual(-3, etor1.Current);
rm1.Remove(3);
Assert.AreEqual(-3, etor1.Current);
var rm2 = new RankedMap <string, int> {
{ "CC", 3 }
};
var etor2 = rm2.Values.GetEnumerator();
Assert.AreEqual(default(int), etor2.Current);
bool ok2 = etor2.MoveNext();
Assert.AreEqual(3, etor2.Current);
rm2.Clear();
Assert.AreEqual(3, etor2.Current);
}
public void CrashRmk_gcClear_NotSupported()
{
var rm = new RankedMap <int, int>();
var gc = (ICollection <int>)rm.Keys;
gc.Clear();
}
public void UnitRmv_gcGetEnumerator()
{
var rm = new RankedMap <string, int?> {
Capacity = 4
};
var gc = (ICollection <int?>)rm.Values;
int n = 10;
for (int k = 0; k < n; ++k)
{
rm.Add(k.ToString(), k + 1000);
}
int expected = 0;
var etor = gc.GetEnumerator();
var rewoundKey = etor.Current;
Assert.AreEqual(rewoundKey, default(int?));
while (etor.MoveNext())
{
var val = etor.Current;
Assert.AreEqual(expected + 1000, val);
++expected;
}
Assert.AreEqual(n, expected);
}
public void CrashRmv_gcRemove_NotSupported()
{
var rm = new RankedMap <int, int>();
var gc = (ICollection <int>)rm.Values;
gc.Remove(9);
}
public void CrashRmk_gcAdd_NotSupported()
{
var rm = new RankedMap <string, int>();
var gc = (ICollection <string>)rm.Keys;
gc.Add("omega");
}
public void UnitRm_gcIsReadonly()
{
var rm = new RankedMap <string, int>();
var gcp = (ICollection <KeyValuePair <string, int> >)rm;
Assert.IsFalse(gcp.IsReadOnly);
}
public void UnitRm_ElementsFrom()
{
var rm = new RankedMap <int, int> {
Capacity = 4
};
for (int i = 1; i <= 1000; ++i)
{
rm.Add(i, -i);
}
int firstKey = -1;
int actual1 = 0;
foreach (var e in rm.ElementsFrom(501))
{
if (actual1 == 0)
{
firstKey = e.Key;
}
++actual1;
}
int actual2 = 0;
foreach (var e in rm.ElementsFrom(-1))
{
++actual2;
}
Assert.AreEqual(501, firstKey);
Assert.AreEqual(500, actual1);
Assert.AreEqual(1000, actual2);
}
public void UnitRm_ocIsSynchronized()
{
var rm = new RankedMap <string, int>();
var oc = (ICollection)rm;
Assert.IsFalse(oc.IsSynchronized);
}
public void UnitRm_ElementsFromMissingVal()
{
var rm = new RankedMap <int, int>()
{
Capacity = 6
};
#if STRESS
int n = 1000;
#else
int n = 10;
#endif
for (int i = 0; i < n; i += 2)
{
rm.Add(i, -i);
}
for (int i = 1; i < n - 1; i += 2)
{
foreach (var item in rm.ElementsFrom(i))
{
Assert.AreEqual(i + 1, item.Key, "Incorrect key");
break;
}
}
}
public void UnitRm_Clear()
{
var rm = new RankedMap <string, int> {
Capacity = 4
};
rm.Add("foo", 1);
rm.Add("foo", 2);
rm.Add("zax", 3);
rm.Add("zax", 4);
rm.Add("fod", 5);
Assert.AreEqual(5, rm.Count);
rm.Clear();
Assert.AreEqual(0, rm.Count);
int actualCount = 0;
foreach (var pair in rm)
{
++actualCount;
}
Assert.AreEqual(0, actualCount);
}
public void UnitRm_ElementsBetweenIndexes()
{
var rm = new RankedMap <int, int> {
Capacity = 4
};
int n = 30;
for (int ii = 0; ii < n; ++ii)
{
rm.Add(ii, -ii);
}
for (int p1 = 0; p1 < n; ++p1)
{
for (int p2 = p1; p2 < n; ++p2)
{
int actual = 0;
foreach (var pair in rm.ElementsBetweenIndexes(p1, p2))
{
actual += pair.Key;
}
int expected = (p2 - p1 + 1) * (p1 + p2) / 2;
Assert.AreEqual(expected, actual);
}
}
}
public void CrashRm_ContainsKey_ArgumentNull()
{
var rm = new RankedMap <string, int> {
{ "beta", 2 }
};
var zz = rm.ContainsKey(null);
}
public void UnitRm_GetEnumeratorPastEnd()
{
var rm2 = new RankedMap <string, int>();
bool isMoved;
int actualCount = 0, total = 0;
rm2.Add("three", 3);
rm2.Add("one", 1);
rm2.Add("five", 5);
rm2.Add("three", 3);
using (var etor = rm2.GetEnumerator())
{
while (etor.MoveNext())
{
++actualCount;
total += etor.Current.Value;
}
isMoved = etor.MoveNext();
}
Assert.AreEqual(4, actualCount);
Assert.AreEqual(12, total);
Assert.IsFalse(isMoved);
}
public void UnitRm_CopyTo2()
{
var rm = new RankedMap <int, int>();
int offset = 1, size = 20;
for (int i = 0; i < size; ++i)
{
rm.Add(i + 1000, i + 10000);
}
var pairs = new KeyValuePair <int, int> [size + offset];
rm.CopyTo(pairs, offset);
for (int i = 0; i < offset; ++i)
{
Assert.AreEqual(0, pairs[i].Key);
Assert.AreEqual(0, pairs[i].Value);
}
for (int i = 0; i < size; ++i)
{
Assert.AreEqual(i + 1000, pairs[i + offset].Key);
Assert.AreEqual(i + 10000, pairs[i + offset].Value);
}
}
public void UnitRm_Comparer()
{
var rm = new RankedMap <string, int>();
IComparer <string> comp = rm.Comparer;
Assert.AreEqual(Comparer <string> .Default, comp);
}
public void UnitRm_IndexOfKey1()
{
var rm = new RankedMap <int, int> {
Capacity = 5
};
for (int ii = 0; ii < 500; ii += 2)
{
rm.Add(ii, ii + 1000);
}
for (int ii = 0; ii < 500; ii += 2)
{
int ix = rm.IndexOfKey(ii);
Assert.AreEqual(ii / 2, ix);
}
int iw = rm.IndexOfKey(-1);
Assert.AreEqual(~0, iw);
int iy = rm.IndexOfKey(500);
Assert.AreEqual(~250, iy);
}
public void UnitRm_pcEtorPairPastEnd()
{
var rm = new RankedMap <string, int> {
{ "nine", 9 }
};
IEnumerator <KeyValuePair <string, int> > pcEtor = rm.GetEnumerator();
KeyValuePair <string, int> pair0 = pcEtor.Current;
Assert.AreEqual(default(int), pair0.Value);
Assert.AreEqual(default(string), pair0.Key);
pcEtor.MoveNext();
KeyValuePair <string, int> pair1 = pcEtor.Current;
Assert.AreEqual("nine", pair1.Key);
Assert.AreEqual(9, pair1.Value);
object oPair1 = ((IEnumerator)pcEtor).Current;
Assert.AreEqual("nine", ((KeyValuePair <string, int>)oPair1).Key);
Assert.AreEqual(9, ((KeyValuePair <string, int>)oPair1).Value);
pcEtor.MoveNext();
KeyValuePair <string, int> pair2 = pcEtor.Current;
Assert.AreEqual(default(string), pair2.Key);
Assert.AreEqual(default(int), pair2.Value);
}
public void UnitRm_Remove2()
{
var rm0 = new RankedMap <int, int>();
var rm1 = new RankedMap <int, int> {
Capacity = 5
};
var rm2 = new RankedMap <int, int> {
Capacity = 5
};
foreach (int ii in new int[] { 3, 5, 5, 7, 7, 7, 9 })
{
rm1.Add(ii, -ii);
}
foreach (int ii in new int[] { 3, 3, 3, 5, 5, 5, 7, 7, 7, 9 })
{
rm2.Add(ii, -ii);
}
var rem0 = rm0.Remove(0, 1);
Assert.AreEqual(0, rem0);
var rem2 = rm1.Remove(2, 2);
Assert.AreEqual(0, rem2);
var rem70 = rm1.Remove(7, 0);
Assert.AreEqual(0, rem70);
var rem7 = rm1.Remove(7, 1);
Assert.AreEqual(1, rem7);
Assert.AreEqual(6, rm1.Count);
var rem5 = rm1.Remove(5, 3);
Assert.AreEqual(2, rem5);
Assert.AreEqual(4, rm1.Count);
var rem9 = rm1.Remove(10);
Assert.IsFalse(rem9);
var rem53 = rm2.Remove(5, 3);
Assert.AreEqual(3, rem53);
var rem33 = rm2.Remove(3, Int32.MaxValue);
Assert.AreEqual(3, rem33);
var rem99 = rm2.Remove(9, 9);
Assert.AreEqual(1, rem99);
Assert.AreEqual(3, rm2.Count);
}
public void UnitRm_EtorCurrentHotUpdate()
{
var rm1 = new RankedMap <int, int>();
var kv1 = new KeyValuePair <int, int> (1, -1);
var kvd1 = new KeyValuePair <int, int> (default(int), default(int));
rm1.Add(kv1.Key, kv1.Value);
var etor1 = rm1.GetEnumerator();
Assert.AreEqual(kvd1, etor1.Current);
bool ok1 = etor1.MoveNext();
Assert.AreEqual(kv1, etor1.Current);
rm1.Remove(kv1.Key);
Assert.AreEqual(kv1, etor1.Current);
var rm2 = new RankedMap <string, int>();
var kv2 = new KeyValuePair <string, int> ("MM", 13);
var kvd2 = new KeyValuePair <string, int> (default(string), default(int));
rm2.Add(kv2.Key, kv2.Value);
var etor2 = rm2.GetEnumerator();
Assert.AreEqual(kvd2, etor2.Current);
bool ok2 = etor2.MoveNext();
Assert.AreEqual(kv2, etor2.Current);
rm2.Clear();
Assert.AreEqual(kv2, etor2.Current);
}
public void UnitRm_RemoveAll()
{
var rm0 = new RankedMap <int, int>();
var rm = new RankedMap <int, int> {
Capacity = 4
};
foreach (var ii in new int[] { 3, 3, 5, 5, 7, 7 })
{
rm.Add(ii, -ii);
}
int rem0 = rm0.RemoveAll(new int[] { 2 });
Assert.AreEqual(0, rem0);
int rem2 = rm.RemoveAll(new int[] { 2 });
Assert.AreEqual(0, rem2);
int rem57 = rm.RemoveAll(new int[] { 3, 3, 3, 7 });
Assert.AreEqual(3, rem57);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(new int[] { 5, 5, 7 }, rm.Keys));
}
public void UnitRmk_gcIsSynchronized()
{
var rm = new RankedMap <int, int>();
var oc = (ICollection)rm.Keys;
Assert.IsFalse(oc.IsSynchronized);
}
