public void UnitRb_Clear()
{
var rb = new RankedBag <int>();
for (int ix = 0; ix < 50; ++ix)
{
rb.Add(ix);
}
Assert.AreEqual(50, rb.Count);
int k1 = 0;
foreach (var i1 in rb.Reverse())
{
++k1;
}
Assert.AreEqual(50, k1);
rb.Clear();
int k2 = 0;
foreach (var i1 in rb.Reverse())
{
++k2;
}
Assert.AreEqual(0, k2);
}
public void CrashRb_ContainsAll_ArgumentNull()
{
var rb = new RankedBag <int> {
5
};
var zz = rb.ContainsAll(null);
}
public void UnitRb_EtorCurrentHotUpdate()
{
var rb1 = new RankedBag <int> {
2
};
var etor1 = rb1.GetEnumerator();
Assert.AreEqual(default(int), etor1.Current);
bool ok1 = etor1.MoveNext();
Assert.IsTrue(ok1);
Assert.AreEqual(2, etor1.Current);
rb1.Remove(2);
Assert.AreEqual(2, etor1.Current);
var rb2 = new RankedBag <string> {
"BB"
};
var etor2 = rb2.GetEnumerator();
Assert.AreEqual(default(string), etor2.Current);
bool ok2 = etor2.MoveNext();
Assert.AreEqual("BB", etor2.Current);
rb2.Clear();
Assert.AreEqual("BB", etor2.Current);
}
public void UnitRb_oReset()
{
var rb = new RankedBag <int> {
Capacity = 4
};
var ia = new int[] { 1, 2, 2, 5, 8, 8, 9 };
foreach (var x in ia)
{
rb.Add(x);
}
var etor = rb.GetEnumerator();
int ix1 = 0;
while (etor.MoveNext())
{
Assert.AreEqual(ia[ix1], etor.Current);
++ix1;
}
Assert.AreEqual(ia.Length, ix1);
((System.Collections.IEnumerator)etor).Reset();
int ix2 = 0;
while (etor.MoveNext())
{
Assert.AreEqual(ia[ix2], etor.Current);
++ix2;
}
Assert.AreEqual(ia.Length, ix2);
}
public void UnitRb_AddNull()
{
var rb = new RankedBag <NameItem>();
rb.Add(null);
Assert.AreEqual(1, rb.Count);
}
public void UnitRb_GetEnumerator()
{
var rb = new RankedBag <int> {
Capacity = 4
};
for (int ii = 0; ii < 10; ++ii)
{
rb.Add(ii);
}
var etor = rb.GetEnumerator();
int ix = 0;
while (etor.MoveNext())
{
int gActual = etor.Current;
object oActual = ((System.Collections.IEnumerator)etor).Current;
Assert.AreEqual(ix, gActual);
Assert.AreEqual(ix, oActual);
++ix;
}
Assert.AreEqual(10, ix);
int gActualEnd = etor.Current;
Assert.AreEqual(default(int), gActualEnd);
bool isValid = etor.MoveNext();
Assert.IsFalse(isValid);
}
public void UnitRb_ElementsBetweenIndexes()
{
int n = 33;
var rb = new RankedBag <int> {
Capacity = 4
};
for (int ii = 0; ii < n; ++ii)
{
rb.Add(ii);
}
for (int p1 = 0; p1 < n; ++p1)
{
for (int p2 = p1; p2 < n; ++p2)
{
int actual = 0;
foreach (var val in rb.ElementsBetweenIndexes(p1, p2))
{
actual += val;
}
int expected = (p2 - p1 + 1) * (p1 + p2) / 2;
Assert.AreEqual(expected, actual);
}
}
}
public void UnitRb_ContainsAll()
{
var rb1 = new RankedBag <int> {
Capacity = 4
};
foreach (var ii in new int[] { 3, 5, 5, 5, 7, 7, 9 })
{
rb1.Add(ii);
}
var rb2 = new RankedBag <int> {
Capacity = 4
};
foreach (var ii in rb1)
{
rb2.Add(ii);
}
Assert.IsTrue(rb1.ContainsAll(new int[] { }));
Assert.IsTrue(rb1.ContainsAll(new int[] { 5, 5 }));
Assert.IsTrue(rb1.ContainsAll(new int[] { 5, 5, 5 }));
Assert.IsTrue(rb1.ContainsAll(new int[] { 5, 7 }));
Assert.IsFalse(rb1.ContainsAll(new int[] { 5, 5, 5, 5 }));
Assert.IsFalse(rb1.ContainsAll(new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }));
Assert.IsTrue(rb1.ContainsAll(rb2));
}
public void StressRb_Counts()
{
#if STRESS
int n = 136;
#else
int n = 5;
#endif
int reps = 100;
for (int order = 4; order <= n; order += 8)
{
var rb = new RankedBag <int> {
Capacity = order
};
for (int ix = 1; ix <= reps; ++ix)
{
rb.Add(ix, ix);
}
for (int ix = 1; ix <= reps; ++ix)
{
Assert.AreEqual(ix, rb.GetCount(ix));
}
Assert.AreEqual((reps + 1) * reps / 2, rb.Count);
Assert.AreEqual(reps, rb.GetDistinctCount());
}
}
static void Main()
{
var bag1 = new RankedBag <Exam> (new ExamComparer());
bag1.Add(new Exam(5, "Jack"));
bag1.Add(new Exam(2, "Ned"));
bag1.Add(new Exam(2, "Betty"));
bag1.Add(new Exam(3, "Paul"));
bag1.Add(new Exam(5, "John"));
Console.WriteLine("Items are inserted after other items that compare equally:");
foreach (var item in bag1)
{
Console.WriteLine($" {item}");
}
string fileName = "Exams.bin";
IFormatter formatter = new BinaryFormatter();
SerializeExams(fileName, bag1, formatter);
Console.WriteLine($"\nWrote {bag1.Count} items to file '{fileName}'.");
Console.WriteLine();
RankedBag <Exam> bag2 = DeserializeExams(fileName, formatter);
Console.WriteLine($"Read back {bag2.Count} items:");
foreach (var p2 in bag2)
{
Console.WriteLine($" {p2}");
}
}
public void UnitRbq_Reverse()
{
var rb0 = new RankedBag <int>();
var rb1 = new RankedBag <int> {
Capacity = 4
};
int n = 400;
for (int i1 = 0; i1 < n; ++i1)
{
rb1.Add(i1 / 2);
}
int a0 = 0, a1 = 0;
#if TEST_BCL
foreach (var k0 in Enumerable.Reverse(rb0))
{
++a0;
}
foreach (var k1 in Enumerable.Reverse(rb1))
#else
foreach (var k0 in rb0.Reverse())
{
++a0;
}
foreach (var k1 in rb1.Reverse())
#endif
{
++a1;
Assert.AreEqual((n - a1) / 2, k1);
}
Assert.AreEqual(0, a0);
Assert.AreEqual(n, a1);
}
public void UnitRb_ElementsFrom()
{
var rb0 = new RankedBag <int>();
var rb1 = new RankedBag <int> {
Capacity = 4
};
var rb2 = new RankedBag <int> (new int[] { 5, 5, 5, 5, 5 });
foreach (var i1 in new int[] { 3, 4, 5, 5, 6, 6, 7, 7, 8 })
{
rb1.Add(i1);
}
var d0 = new System.Collections.Generic.List <int> (rb0.ElementsFrom(0));
Assert.AreEqual(0, d0.Count);
var d1 = new System.Collections.Generic.List <int> (rb1.ElementsFrom(6));
Assert.AreEqual(5, d1.Count);
var d2 = new System.Collections.Generic.List <int> (rb1.ElementsFrom(1));
Assert.AreEqual(9, d2.Count);
var d3 = new System.Collections.Generic.List <int> (rb2.ElementsFrom(5));
Assert.AreEqual(5, d3.Count);
var d5 = new System.Collections.Generic.List <int> (rb2.ElementsFrom(9));
Assert.AreEqual(0, d5.Count);
}
public void StressRbq_SkipF()
{
var rb = new RankedBag <int> {
Capacity = 5
};
int n = 25;
for (int ix = 0; ix < n; ++ix)
{
rb.Add(n + ix);
}
for (int s1 = 0; s1 <= n; ++s1)
{
for (int s2 = 0; s2 <= n - s1; ++s2)
{
int e0 = n + s1 + s2;
foreach (var a0 in rb.Skip(s1).Skip(s2))
{
Assert.AreEqual(e0, a0);
++e0;
}
Assert.AreEqual(n + n, e0);
}
}
}
public void UnitRbq_SkipWhile3R()
{
var rb = new RankedBag <int> {
Capacity = 5
};
Assert.AreEqual(0, SLE.Count(rb.Reverse().SkipWhile((x, i) => false)));
Assert.AreEqual(0, SLE.Count(rb.Reverse().SkipWhile((x, i) => true)));
Assert.AreEqual(0, SLE.Count(rb.Reverse().SkipWhile((x, i) => true).SkipWhile((x, i) => true)));
rb.Add(1);
Assert.AreEqual(0, SLE.Count(rb.Reverse().SkipWhile((x, i) => true)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1 }, rb.Reverse().SkipWhile((x, i) => false)));
rb.Add(2);
rb.Add(3);
Assert.IsTrue(SLE.SequenceEqual(new int[] { 2, 1 }, rb.Reverse().SkipWhile((x, i) => x % 2 != 0)));
for (int i = 4; i < 50; ++i)
{
rb.Add(i);
}
Assert.IsTrue(SLE.SequenceEqual(new int[] { 3, 2, 1 }, rb.Reverse().Skip(20).SkipWhile((x, i) => x % 3 != 0 || i < 24)));
}
public void UnitRbq_ElementAtOrDefault()
{
var rb = new RankedBag <int>();
#if TEST_BCL
int keyN = Enumerable.ElementAtOrDefault(rb, -1);
int key0 = Enumerable.ElementAtOrDefault(rb, 0);
#else
int keyN = rb.ElementAtOrDefault(-1);
int key0 = rb.ElementAtOrDefault(0);
#endif
Assert.AreEqual(default(int), keyN);
Assert.AreEqual(default(int), key0);
rb.Add(9);
#if TEST_BCL
int keyZ = Enumerable.ElementAtOrDefault(rb, 0);
int key1 = Enumerable.ElementAtOrDefault(rb, 1);
#else
int keyZ = rb.ElementAtOrDefault(0);
int key1 = rb.ElementAtOrDefault(1);
#endif
Assert.AreEqual(9, keyZ);
Assert.AreEqual(default(int), key1);
}
public void UnitRbq_Skip()
{
var rb = new RankedBag <int> {
Capacity = 5
};
Assert.AreEqual(0, SLE.Count(rb.Skip(0)));
Assert.AreEqual(0, SLE.Count(rb.Skip(-1)));
Assert.AreEqual(0, SLE.Count(rb.Skip(1)));
rb.Add(1);
rb.Add(2);
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1, 2 }, rb.Skip(-1)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1, 2 }, rb.Skip(0)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 2 }, rb.Skip(1)));
Assert.AreEqual(0, SLE.Count(rb.Skip(2)));
Assert.AreEqual(0, SLE.Count(rb.Skip(3)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1, 2 }, rb.Skip(0).Skip(-1)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1, 2 }, rb.Skip(0).Skip(0)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 2 }, rb.Skip(0).Skip(1)));
Assert.AreEqual(0, SLE.Count(rb.Skip(0).Skip(3)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 2, 1 }, rb.Reverse().Skip(-1)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 2, 1 }, rb.Reverse().Skip(0)));
Assert.IsTrue(SLE.SequenceEqual(new int[] { 1 }, rb.Reverse().Skip(1)));
Assert.AreEqual(0, SLE.Count(rb.Reverse().Skip(2)));
Assert.AreEqual(0, SLE.Count(rb.Reverse().Skip(3)));
}
public void UnitRb_RetainAll()
{
var rb0 = new RankedBag <int>();
var rb1 = new RankedBag <int> {
Capacity = 4
};
var rb2 = new RankedBag <int> {
3, 5, 7
};
foreach (int ii in new int[] { 3, 4, 5, 5, 6, 6, 6, 7, 7, 8 })
{
rb1.Add(ii);
}
int del0 = rb0.RetainAll(new int[] { 2, 4 });
Assert.AreEqual(0, del0);
Assert.AreEqual(0, rb0.Count);
int del1 = rb1.RetainAll(new int[] { 1, 4, 4, 6, 6, 9 });
Assert.AreEqual(7, del1);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(new int[] { 4, 6, 6 }, rb1));
int del2 = rb2.RetainAll(new int[] { });
Assert.AreEqual(3, del2);
Assert.AreEqual(0, rb2.Count);
}
static void Main()
{
var crayons = new RankedBag <string> (StringComparer.InvariantCultureIgnoreCase)
{
"red", "yellow", "black", "BLACK"
};
crayons.Add("blue");
Console.WriteLine($"There are {crayons.Count} total crayons:");
foreach (var crayon in crayons)
{
Console.WriteLine($" {crayon}");
}
Console.WriteLine($"\nThere are {crayons.GetDistinctCount()} distinct colors:");
foreach (var crayon in crayons.Distinct())
{
Console.WriteLine($" {crayon}");
}
Console.WriteLine($"\nGot 'gold' crayon? {crayons.Contains ("gold")}");
// RetainAll respects cardinality so the oldest 'black' is removed:
crayons.RetainAll(new string[] { "white", "grey", "Black", "red" });
Console.WriteLine("\nAfter RetainAll: ");
foreach (var crayon in crayons)
{
Console.WriteLine($" {crayon}");
}
}
public void UnitRbqx_oEtorGetEnumerator()
{
var ia = new int[] { 2, 2, 3, 3, 5, 6, 8 };
var rb = new RankedBag <int> (ia)
{
Capacity = 4
};
var oAble1 = (System.Collections.IEnumerable)rb;
System.Collections.IEnumerator oEtor1 = oAble1.GetEnumerator();
var oAble2 = (System.Collections.IEnumerable)oEtor1;
System.Collections.IEnumerator oEtor2 = oAble2.GetEnumerator();
int ix = 0;
while (oEtor2.MoveNext())
{
object oItem = oEtor2.Current;
Assert.AreEqual(ia[ix], oItem);
++ix;
}
Assert.AreEqual(ia.Length, ix);
}
public void UnitRb_Inheritance()
{
var rb = new RankedBag <int> {
42, 21, 63
};
var toIColI = rb as System.Collections.Generic.ICollection <int>;
var toIEnuI = rb as System.Collections.Generic.IEnumerable <int>;
var toIEnuO = rb as System.Collections.IEnumerable;
var toIColO = rb as System.Collections.ICollection;
var toIRocI = rb as System.Collections.Generic.IReadOnlyCollection <int>;
Assert.IsNotNull(toIColI);
Assert.IsNotNull(toIEnuI);
Assert.IsNotNull(toIEnuO);
Assert.IsNotNull(toIColO);
Assert.IsNotNull(toIRocI);
int ObjEnumCount = 0;
for (var oe = toIEnuO.GetEnumerator(); oe.MoveNext();)
{
++ObjEnumCount;
}
Assert.AreEqual(3, toIColI.Count);
Assert.AreEqual(3, System.Linq.Enumerable.Count(toIEnuI));
Assert.AreEqual(3, ObjEnumCount);
Assert.AreEqual(3, toIColO.Count);
Assert.AreEqual(3, toIRocI.Count);
}
public void UnitRb_RemoveAll()
{
var rb0 = new RankedBag <int>();
var rb = new RankedBag <int> {
Capacity = 4
};
foreach (var ii in new int[] { 3, 5, 5, 7, 7 })
{
rb.Add(ii);
}
int rem0 = rb0.RemoveAll(new int[] { 2 });
Assert.AreEqual(0, rem0);
int rem1 = rb.RemoveAll(new int[] { });
Assert.AreEqual(0, rem1);
int rem2 = rb.RemoveAll(new int[] { 2 });
Assert.AreEqual(0, rem0);
int rem57 = rb.RemoveAll(new int[] { 5, 7 });
Assert.AreEqual(2, rem57);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(new int[] { 3, 5, 7 }, rb));
int rem4 = rb.RemoveAll(rb);
Assert.AreEqual(3, rem4);
Assert.AreEqual(0, rb.Count);
}
public void UnitRb_Remove1()
{
var rb0 = new RankedBag <int>();
var rb = new RankedBag <int> {
Capacity = 4
};
foreach (int ii in new int[] { 3, 5, 5, 7, 7, 7, 9 })
{
rb.Add(ii);
}
bool rem0 = rb0.Remove(0);
Assert.IsFalse(rem0);
bool rem2 = rb.Remove(2);
Assert.IsFalse(rem2);
bool rem7 = rb.Remove(7);
Assert.IsTrue(rem7);
Assert.AreEqual(4, rb.Count);
bool rem5 = rb.Remove(5);
Assert.IsTrue(rem5);
Assert.AreEqual(2, rb.Count);
bool rem10 = rb.Remove(10);
Assert.IsFalse(rem10);
}
public void UnitRb_ocSyncRoot()
{
var rb = new RankedBag <int>();
var oc = (System.Collections.ICollection)rb;
Assert.IsFalse(oc.SyncRoot.GetType().IsValueType);
}
public void UnitRb_CopyTo3()
{
var s4 = new int[] { 3, 5, 5, 7 };
var e2 = new int[] { 0, 0 };
var e3 = new int[] { 0, 3, 5 };
var e5 = new int[] { 0, 3, 5, 5, 0 };
var d2 = new int[2];
var d3 = new int[3];
var d4 = new int[4];
var d5 = new int[5];
var d6 = new int[6];
var rb = new RankedBag <int> (s4);
rb.CopyTo(d2, 1, 0);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(e2, d2));
rb.CopyTo(d3, 1, 2);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(e3, d3));
rb.CopyTo(d4, 0, 4);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(s4, d4));
rb.CopyTo(d5, 1, 3);
Assert.IsTrue(System.Linq.Enumerable.SequenceEqual(e5, d5));
}
public void CrashRb_RemoveRange_Argument()
{
var rb = new RankedBag <int> {
3, 5
};
rb.RemoveRange(1, 2);
}
public void CrashRb_RemoveAtA_ArgumentOutOfRange()
{
var rb = new RankedBag <int> {
1
};
rb.RemoveAt(-1);
}
public void UnitRb_GetDistinctCount()
{
var rb0 = new RankedBag <int>();
var rb = new RankedBag <int> (new int[] { 3, 5, 5, 5, 7 });
Assert.AreEqual(0, rb0.GetDistinctCount());
Assert.AreEqual(3, rb.GetDistinctCount());
}
public void CrashRb_CopyTo3_ArgumentNull()
{
var rb = new RankedBag <int> {
2
};
rb.CopyTo(null, 0, 1);
}
public void CrashRb_RetainAll_ArgumentNull()
{
var rb = new RankedBag <int> {
2
};
rb.RetainAll(null);
}
public void CrashRb_CopyTo1_ArgumentNull()
{
var rb = new RankedBag <int> {
1
};
rb.CopyTo(null);
}
public static void CompareAndEquipBags(EasyItem[] C)
{
RankedBag[] RankedBags = new RankedBag[C.Length + 4];
//PPather.WriteLine(String.Format("AutoEquip: RankedBags.Length = {0}", RankedBags.Length));
//PPather.WriteLine(String.Format("AutoEquip: containers.Count = {0}", C.Length));
//PPather.WriteLine(String.Format("AutoEquip: GPlayerSelf.Me.Bags.Length = {0}", 4));
/* add bags found in inventory */
GItem[] Items = GObjectList.GetItems();
List<long> added = new List<long>();
int nr = 0;
for (nr = 0; nr < C.Length; nr++)
{
if (!Inventory.IsEquippedBag(C[nr].GUID) && !added.Contains(C[nr].GUID))
{
GContainer bag = (GContainer)GObjectList.FindObject(C[nr].GUID);
string SlotName = Inventory.GetBagSlotName(C[nr].GItem);
RankedBag b = new RankedBag(1, bag.SlotCount, bag, C[nr].GItem, SlotName);
RankedBags[nr] = b;
//PPather.WriteLine("AutoEquip: (inventory) RankedBags[{0}] = {1} (SlotCount={2}, GUID={3})", nr, C[nr].Item.Name, bag.SlotCount, C[nr].GUID);
added.Add(C[nr].GUID);
}
}
/* add already equipped bags */
nr = C.Length;
foreach (GItem Item in Items)
{
if (Item.Type.ToString() == "Container" && Inventory.IsEquippedBag(Item.GUID) && !added.Contains(Item.GUID))
{
GContainer bag = (GContainer)GObjectList.FindObject(Item.GUID);
string SlotName = Inventory.GetBagSlotName(Item);
RankedBag b = new RankedBag(0, bag.SlotCount, bag, Item, SlotName);
RankedBags[nr] = b;
//PPather.WriteLine("AutoEquip: (eqiupped) RankedBags[{0}] = {1} (SlotCount={2}, GUID={3})", nr, Item.Name, bag.SlotCount, Item.GUID);
added.Add(Item.GUID);
nr++;
}
}
/* add the empty slots */
int freeslots = 0;
while (nr < (C.Length + 4))
{
RankedBag b = new RankedBag(0, 0, null, null, null);
RankedBags[nr] = b;
nr++;
freeslots++;
}
/* sort bags on slotcount */
Array.Sort(RankedBags);
/* DEBUG print of ranks */
//for (int k = 0; k < RankedBags.Length; k++)
//{
// RankedBag rb = RankedBags[k];
// if (rb != null)
// {
// string name = "null";
// if (rb.item != null) name = rb.item.Name;
// PPather.WriteLine(String.Format("AutoEquip: Rank {0} => {1}({2})", k, name, rb.slots));
// }
//}
/* get the bag slot names to replace (reverse sort) */
List<string> slots = new List<string>();
for (int j = RankedBags.Length - 1; j >= 0; j--)
{
RankedBag r = RankedBags[j];
if (r == null) continue;
if (r.slotname == null) continue;
string name = "null";
if (r.item != null) name = r.item.Name;
slots.Add(r.slotname);
//PPather.WriteLine("AutoEquip: Rank {0} of BagSlot to replace is {1} ({2})", slots.Count, r.slotname, name);
}
String[] BagSlots = slots.ToArray();
int ReplaceSlotIndex = 0;
/* go through RankedBags and make sure the top 4 ranked bags are equipped */
int index = 0; int equipped = 0;
while (index < 4)
{
//PPather.WriteLine("AutoEquip: index={0}, equipped={1}, freeslots={2}", index, equipped, freeslots);
RankedBag r = RankedBags[index];
if (r != null)
{
string name = "null";
if (r.item != null) name = r.item.Name;
if (r.location == 0)
{
//PPather.WriteLine("AutoEquip: {0} rank[{1}] is equipped", name, index);
}
else if (freeslots > 0)
{
//PPather.WriteLine("AutoEquip: {0} rank[{1}] is new bag", name, index);
EquipBag(r.item, true, null);
equipped++;
freeslots--;
}
else
{
//PPather.WriteLine("AutoEquip: {0} rank[{1}] is better bag", name, index);
EquipBag(r.item, false, BagSlots[ReplaceSlotIndex]);
equipped++;
ReplaceSlotIndex++;
}
}
index++;
}
}
