[Test] public void Test_Key_Twice()
{
SkipList sl = new SkipList();
sl.Add("one", "one");
sl.Add("one", "one");
}
public void RunTest() {
var rnd = new Random((int)DateTime.Now.Ticks);
var tempSL = new SkipList<int>();
for(int i = 0; i < 512; i++) {
int adding = rnd.Next(512);
tempSL.Add(adding);
}
for(int i = 0; i < 512; i++) {
int val = rnd.Next(512);
switch(rnd.Next(3)) {
case 0:
tempSL.Add(val);
break;
case 1:
tempSL.Remove(val);
break;
case 2:
tempSL.Contains(val);
break;
}
}
Console.WriteLine("SkipList : " + tempSL);
}
public void CountExample()
{
var skipList = new SkipList <string, int>();
// SkipList count is 0.
Assert.AreEqual(0, skipList.Count);
// Add a cat.
skipList.Add("cat", 1);
// SkipList count is 1.
Assert.AreEqual(1, skipList.Count);
// Add a dog
skipList.Add("dog", 2);
// SkipList count is 2.
Assert.AreEqual(2, skipList.Count);
// Clear the skipList - thereby removing all items contained.
skipList.Clear();
// SkipList is empty again with 0 count.
Assert.AreEqual(0, skipList.Count);
}
public static void DoTest()
{
var skipList = new SkipList <int>();
for (int i = 100; i >= 50; --i)
{
skipList.Add(i);
}
for (int i = 0; i <= 35; ++i)
{
skipList.Add(i);
}
for (int i = -15; i <= 0; ++i)
{
skipList.Add(i);
}
for (int i = -15; i >= -35; --i)
{
skipList.Add(i);
}
Assert.True(skipList.Count == 124);
skipList.Clear();
for (int i = 100; i >= 0; --i)
{
skipList.Add(i);
}
Assert.True(skipList.Count == 101);
}
[Test] public void Test_Key_Twice()
{
SkipList sl = new SkipList();
sl.Add("one", "one");
Assert.That(() => sl.Add("one", "one"), Throws.ArgumentException);
}
public void Add_OneItem_ItemInList()
{
_target.Add(0, _values[0]);
var value = _target.GetValue(0);
Assert.AreEqual(_values[0], value);
}
public void AddExample()
{
var skipList = new SkipList<string, int>();
skipList.Add("cat", 1);
skipList.Add("dog", 2);
skipList.Add("canary", 3);
// There will be 3 items in the skipList.
Assert.AreEqual(3, skipList.Count);
}
[Test] public void Test_Add()
{
SkipList sl = new SkipList();
Assert.AreEqual(0, sl.Count);
sl.Add("1", "bar");
Assert.AreEqual(1, sl.Count);
sl.Add("2", "baz");
Assert.AreEqual(2, sl.Count);
}
public void ExceptionDuplicate4()
{
var skipList = new SkipList <int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
Assert.Throws <ArgumentException>(() => skipList.Add(10, "15"));
}
public void ExcetpionDuplicate4()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
skipList.Add(10, "15");
}
public void ExcetpionDuplicate4()
{
var skipList = new SkipList <int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
skipList.Add(10, "15");
}
public void ExceptionDuplicate3()
{
var skipList = new SkipList <int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
skipList.Add(19, "19");
}
public void ExceptionDuplicate3()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
skipList.Add(19, "19");
}
public void TestDuplicateItem4()
{
SkipList <int, string> s = new SkipList <int, string>();
for (int i = 0; i < 20; i++)
{
s.Add(i, i.ToString());
}
s.Add(10, "15");
}
public void TestCount()
{
SkipList <int, string> s = new SkipList <int, string>();
Assert.AreEqual(s.Count, 0);
s.Add(2, "2");
Assert.AreEqual(s.Count, 1);
s.Add(3, "3");
Assert.AreEqual(s.Count, 2);
}
public void Simple()
{
var skipList = new SkipList <int, string>();
Assert.AreEqual(skipList.Count, 0);
skipList.Add(2, "2");
Assert.AreEqual(skipList.Count, 1);
skipList.Add(3, "3");
Assert.AreEqual(skipList.Count, 2);
}
public void SkipListAddDelete5()
{
SkipList <int> list = new SkipList <int>();
list.Add(5);
list.Add(17);
list.Add(2);
list.Add(24);
list.Add(67);
list.Remove(24);
Assert.IsTrue(list.head.Nexts[0].Value == 2 && list.head.Nexts[0].Nexts[0].Value == 5 &&
list.head.Nexts[0].Nexts[0].Nexts[0].Value == 17 && list.head.Nexts[0].Nexts[0].Nexts[0].Nexts[0].Value == 67);
}
public void Simple()
{
var skipList = new SkipList<int, string>();
var originalList = new List<KeyValuePair<int, string>>();
for (var i = 0; i < 100; i++)
{
originalList.Add(new KeyValuePair<int, string>(i, i.ToString()));
skipList.Add(originalList[i]);
}
var list = new List<KeyValuePair<int, string>>();
using (var enumerator = skipList.GetEnumerator())
{
while (enumerator.MoveNext())
{
list.Add(enumerator.Current);
}
}
Assert.AreEqual(list.Count, 100);
for (var i = 0; i < 100; i++)
{
Assert.IsTrue(list.Contains(originalList[i]));
}
}
public void NonIComparable()
{
var skipList = new SkipList <NonComparableTClass, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(new KeyValuePair <NonComparableTClass, string>(new NonComparableTClass(i), i.ToString()));
}
var newSkipList = SerializeUtil.BinarySerializeDeserialize(skipList);
Assert.AreNotSame(skipList, newSkipList);
Assert.AreEqual(skipList.Count, newSkipList.Count);
var sEnumerator = skipList.GetEnumerator();
var newSkipListEnumerator = newSkipList.GetEnumerator();
while (sEnumerator.MoveNext())
{
Assert.IsTrue(newSkipListEnumerator.MoveNext());
Assert.AreEqual(sEnumerator.Current.Key.Number, newSkipListEnumerator.Current.Key.Number);
Assert.AreEqual(sEnumerator.Current.Value, newSkipListEnumerator.Current.Value);
}
Assert.IsFalse(newSkipListEnumerator.MoveNext());
}
public void TestSetItem()
{
SkipList <int, string> s = new SkipList <int, string>();
s.Add(1, "1");
s[1] = "2";
Assert.AreEqual(s[1], "2");
s.Add(2, "2");
s[2] = "3";
Assert.AreEqual(s[2], "3");
}
public void TestCopyTo()
{
SkipList <int, string> s = new SkipList <int, string>();
KeyValuePair <int, string>[] pairs = new KeyValuePair <int, string> [5];
for (int i = 0; i < pairs.Length; i++)
{
pairs[i] = new KeyValuePair <int, string>(i, i.ToString());
s.Add(pairs[i]);
}
KeyValuePair <int, string>[] array = new KeyValuePair <int, string> [50];
s.CopyTo(array, 0);
List <KeyValuePair <int, string> > l = new List <KeyValuePair <int, string> >();
l.Add(array[0]);
l.Add(array[1]);
l.Add(array[2]);
l.Add(array[3]);
l.Add(array[4]);
l.Add(array[5]);
for (int i = 0; i < pairs.Length; i++)
{
Assert.AreEqual(l.Contains(pairs[i]), true);
}
}
public void ItemsDoNotExistAfterRemoving()
{
var lib = new SkipList <int, int>();
var nums = new List <int>(new[] { 44, 22, 1, 56, 3, 90, 31, 15, 26 });
int n = nums.Count;
for (int i = 0; i < n; i++)
{
lib.Add(nums[i], i);
}
nums.Sort();
nums = new List <int>(new[] { 44, 22, 1, 56, 3, 90 });
nums.Sort();
lib.Remove(31);
lib.Remove(15);
lib.Remove(26);
int j = 0;
foreach (var pair in lib)
{
Assert.AreEqual(nums[j], pair.Key);
j++;
}
Assert.AreEqual(n - 3, lib.Count);
}
public void NonIComparable()
{
var skipList = new SkipList<NonComparableTClass, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(new KeyValuePair<NonComparableTClass, string>(new NonComparableTClass(i), i.ToString()));
}
var newSkipList = SerializeUtil.BinarySerializeDeserialize(skipList);
Assert.AreNotSame(skipList, newSkipList);
Assert.AreEqual(skipList.Count, newSkipList.Count);
var sEnumerator = skipList.GetEnumerator();
var newSkipListEnumerator = newSkipList.GetEnumerator();
while (sEnumerator.MoveNext())
{
Assert.IsTrue(newSkipListEnumerator.MoveNext());
Assert.AreEqual(sEnumerator.Current.Key.Number, newSkipListEnumerator.Current.Key.Number);
Assert.AreEqual(sEnumerator.Current.Value, newSkipListEnumerator.Current.Value);
}
Assert.IsFalse(newSkipListEnumerator.MoveNext());
}
public void TestInvalidItemGet2()
{
SkipList <int, string> s = new SkipList <int, string>();
s.Add(1, "aa");
string v = s[2];
}
public void Simple()
{
var skipList = new SkipList <int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(new KeyValuePair <int, string>(i, i.ToString()));
}
var newSkipList = SerializeUtil.BinarySerializeDeserialize(skipList);
Assert.AreNotSame(skipList, newSkipList);
Assert.AreEqual(skipList.Count, newSkipList.Count);
var sEnumerator = skipList.GetEnumerator();
var newSkipListEnumerator = newSkipList.GetEnumerator();
while (sEnumerator.MoveNext())
{
Assert.IsTrue(newSkipListEnumerator.MoveNext());
Assert.AreEqual(sEnumerator.Current.Key, newSkipListEnumerator.Current.Key);
Assert.AreEqual(sEnumerator.Current.Value, newSkipListEnumerator.Current.Value);
}
Assert.IsFalse(newSkipListEnumerator.MoveNext());
}
public void SkipListVsSortedDictionaryAdds()
{
Console.WriteLine("SkipListVsSortedDictionaryAdds");
int[] keys = CreateRandomSetOfKeys(ITEMS);
Console.WriteLine("SkipList");
//Console.ReadLine();
SkipList <int, int> skipList = new SkipList <int, int>();
TimeIt(TRIALS, () =>
{
for (int i = 0; i < ITEMS; i++)
{
skipList.Add(keys[i], i);
}
});
Console.WriteLine("SortedDictionary");
SortedDictionary <int, int> sortedDictionary = new SortedDictionary <int, int>();
TimeIt(TRIALS, () =>
{
for (int i = 0; i < ITEMS; i++)
{
sortedDictionary.Add(keys[i], i);
}
});
}
public void Simple()
{
var skipList = new SkipList <int, string>();
var pairs = new KeyValuePair <int, string> [5];
for (var i = 0; i < pairs.Length; i++)
{
pairs[i] = new KeyValuePair <int, string>(i, i.ToString());
skipList.Add(pairs[i]);
}
var array = new KeyValuePair <int, string> [50];
skipList.CopyTo(array, 0);
var list = new List <KeyValuePair <int, string> >
{
array[0],
array[1],
array[2],
array[3],
array[4],
array[5]
};
foreach (var keyValuePair in pairs)
{
Assert.IsTrue(list.Contains(keyValuePair));
}
}
[Test] public void Test_Get()
{
SkipList sl = new SkipList();
sl.Add("1", "bar");
Assert.AreEqual("bar", sl["1"]);
}
public void Interface()
{
var skipList = new SkipList <int, string>();
var originalList = new List <KeyValuePair <int, string> >();
for (var i = 0; i < 100; i++)
{
originalList.Add(new KeyValuePair <int, string>(i, i.ToString()));
skipList.Add(originalList[i]);
}
var list = new List <KeyValuePair <int, string> >();
var enumerator = ((IEnumerable)skipList).GetEnumerator();
{
while (enumerator.MoveNext())
{
list.Add((KeyValuePair <int, string>)enumerator.Current);
}
}
Assert.AreEqual(list.Count, 100);
for (var i = 0; i < 100; i++)
{
Assert.IsTrue(list.Contains(originalList[i]));
}
}
public void RemoveAllExceptOne()
{
var list = new SkipList <int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!list.Contains(el))
{
list.Add(el);
}
el += i;
}
}
bool removedEverything = true;
for (int i = 0; i < elementsCount - 1; i++)
{
if (!list.Remove(i))
{
removedEverything = false;
}
}
Assert.IsTrue(list.Count == 1 &&
removedEverything &&
list.Head[0].Value == elementsCount - 1);
}
static void Main(string[] args)
{
int n = 10000;
var rd = new Random(DateTime.Now.Millisecond);
var set = new HashSet <int>();
while (set.Count < n)
{
set.Add(rd.Next(0, 3 * n));
}
var sortedList = new SortedList <int, int>();
var t = new Stopwatch();
t.Start();
foreach (var num in set)
{
sortedList.Add(num, 60);
}
t.Stop();
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine(t.ElapsedMilliseconds);
var skipList = new SkipList <int, int>(14, 0.5);
t = new Stopwatch();
t.Start();
foreach (var num in set)
{
skipList.Add(num, 60);
}
t.Stop();
Console.WriteLine(t.ElapsedMilliseconds);
Console.ReadKey();
}
public void TestInvalidItemset2()
{
SkipList <int, string> s = new SkipList <int, string>();
s.Add(1, "aa");
s[10] = "2";
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(new KeyValuePair<int, string>(i, i.ToString()));
}
var newSkipList = SerializeUtil.BinarySerializeDeserialize(skipList);
Assert.AreNotSame(skipList, newSkipList);
Assert.AreEqual(skipList.Count, newSkipList.Count);
var sEnumerator = skipList.GetEnumerator();
var newSkipListEnumerator = newSkipList.GetEnumerator();
while (sEnumerator.MoveNext())
{
Assert.IsTrue(newSkipListEnumerator.MoveNext());
Assert.AreEqual(sEnumerator.Current.Key, newSkipListEnumerator.Current.Key);
Assert.AreEqual(sEnumerator.Current.Value, newSkipListEnumerator.Current.Value);
}
Assert.IsFalse(newSkipListEnumerator.MoveNext());
}
public void Add_WithValue_ShouldInsertNewNode()
{
var list = new SkipList <int>();
list.Add(42);
Assert.Single(list);
}
public void TestInterfaceEnumerator()
{
SkipList <int, string> s = new SkipList <int, string>();
List <KeyValuePair <int, string> > originalList = new List <KeyValuePair <int, string> >();
for (int i = 0; i < 100; i++)
{
originalList.Add(new KeyValuePair <int, string>(i, i.ToString()));
s.Add(originalList[i]);
}
List <KeyValuePair <int, string> > list = new List <KeyValuePair <int, string> >();
IEnumerator e = ((IEnumerable)s).GetEnumerator();
{
while (e.MoveNext())
{
list.Add((KeyValuePair <int, string>)e.Current);
}
}
Assert.AreEqual(list.Count, 100);
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(list.Contains(originalList[i]), true);
}
}
private static void Main(string[] args)
{
int n = 10;
var rd = new Random(DateTime.Now.Millisecond);
var set = new HashSet <int>();
while (set.Count < n)
{
set.Add(rd.Next(0, n));
}
var sortedList = new SortedList <int, int>();
var t = new Stopwatch();
t.Start();
foreach (var num in set)
{
sortedList.Add(num, 1);
}
t.Stop();
Console.WriteLine("Sorted list" + t.Elapsed);
var skipList = new SkipList <int, int>();
t = new Stopwatch();
t.Start();
foreach (var num in set)
{
skipList.Add(num, 1);
}
t.Stop();
Console.WriteLine("Skip list" + t.Elapsed);
Console.ReadLine();
}
public void Simple()
{
var skipList = new SkipList<int, string>();
Assert.IsFalse(skipList.IsReadOnly);
skipList.Add(4, "a");
Assert.IsFalse(skipList.IsReadOnly);
}
public void Simple()
{
var skipList = new SkipList<int, string>();
Assert.AreEqual(skipList.Count, 0);
skipList.Add(4, "a");
Assert.AreEqual(skipList.Count, 1);
skipList.Clear();
Assert.AreEqual(skipList.Count, 0);
skipList.Add(5, "a");
skipList.Add(6, "a");
Assert.AreEqual(skipList.Count, 2);
skipList.Clear();
Assert.AreEqual(skipList.Count, 0);
}
public void Simple()
{
var skipList = new SkipList<int, string>();
string val;
Assert.IsFalse(skipList.TryGetValue(5, out val));
skipList.Add(3, "4");
Assert.IsFalse(skipList.TryGetValue(5, out val));
Assert.IsTrue(skipList.TryGetValue(3, out val));
Assert.AreEqual(val, "4");
}
public void Simple()
{
var skipList = new SkipList<int, string>();
Assert.AreEqual(skipList.CurrentListLevel, 0);
for (var i = 0; i < 100; i++)
{
skipList.Add(new KeyValuePair<int, string>(i, i.ToString()));
}
Assert.Greater(skipList.CurrentListLevel, 0);
}
public void AddIsHookedUpToInsert()
{
using (ShimsContext.Create())
{
int insertedValue = int.MinValue;
ShimSkipList<int>.AllInstances.InsertT0 = (skipList, value) => { insertedValue = value; };
ICollection<int> collection = new SkipList<int>();
collection.Add(50);
Assert.AreEqual<int>(50, insertedValue);
}
}
public void DoneVisitor()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 20; i++)
{
skipList.Add(i, i.ToString());
}
var completedTrackingVisitor = new CompletedTrackingVisitor<KeyValuePair<int, string>>();
skipList.AcceptVisitor(completedTrackingVisitor);
}
public void ExceptionInvalid3()
{
var skipList = new SkipList<int, string>();
var pairs = new KeyValuePair<int, string>[5];
for (var i = 0; i < pairs.Length; i++)
{
pairs[i] = new KeyValuePair<int, string>(i, i.ToString());
skipList.Add(pairs[i]);
}
skipList.CopyTo(null, 0);
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
Assert.IsTrue(skipList.ContainsKey(i));
}
for (var i = 100; i < 150; i++)
{
Assert.IsFalse(skipList.ContainsKey(i));
}
}
public void KeyValuePair()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
}
Assert.IsTrue(skipList.Contains(new KeyValuePair<int, string>(5, "5")));
Assert.IsTrue(skipList.Contains(new KeyValuePair<int, string>(6, "6")));
Assert.IsFalse(skipList.Contains(new KeyValuePair<int, string>(5, "6")));
Assert.IsFalse(skipList.Contains(new KeyValuePair<int, string>(100, "100")));
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
}
var list = new List<string>();
list.AddRange(skipList.Values);
Assert.AreEqual(list.Count, 100);
for (var i = 0; i < 100; i++)
{
Assert.IsTrue(list.Contains(i.ToString()));
}
}
public void IndexWord(string word, int index)
{
if (word.Length != _wordLength)
throw new Exception("Invalid word length");
for (int i = 0; i < word.Length; i++)
{
var dict = _index[i];
SkipList list;
if (dict.TryGetValue(word[i], out list))
{
list.Add(index);
}
else
{
list = new SkipList();
dict.Add(word[i], list);
list.Add(index);
}
}
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
}
var visitor = new TrackingVisitor<KeyValuePair<int, string>>();
skipList.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 100);
using (var enumerator = skipList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Assert.IsTrue(visitor.TrackingList.Contains(enumerator.Current));
}
}
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
}
for (var i = 0; i < 100; i++)
{
if ((i % 2) == 0)
{
Assert.IsTrue(skipList.Remove(i));
}
else
{
Assert.IsTrue(skipList.Remove(new KeyValuePair<int, string>(i, "a")));
}
Assert.AreEqual(skipList.Count, 99 - i);
Assert.IsFalse(skipList.ContainsKey(i));
}
}
private static void TestSkipList()
{
Console.WriteLine("TestSkipList");
SkipList<int, string> skipList = new SkipList<int, string>();
Random rnd = new Random(0);
Console.WriteLine("Add");
Stopwatch swAdd = Stopwatch.StartNew();
for (int i = 0; i < MAX; ++i)
{
Console.Write("{0}\r", i);
int next = rnd.Next();
skipList.Add(next, next.ToString());
}
swAdd.Stop();
rnd = new Random(0);
Console.WriteLine("Remove");
Stopwatch swRemove = Stopwatch.StartNew();
for (int i = 0; i < MAX; ++i)
{
Console.Write("{0}\r", i);
int next = rnd.Next();
skipList.Remove(next);
}
swRemove.Stop();
rnd = new Random(0);
Console.WriteLine("ContainsKey");
Stopwatch swContainsKey = Stopwatch.StartNew();
for (int i = 0; i < MAX; ++i)
{
Console.Write("{0}\r", i);
int next = rnd.Next();
bool res = skipList.ContainsKey(next);
if (res)
{
Console.WriteLine("Bug");
}
}
swContainsKey.Stop();
Console.WriteLine("Add = {0}", swAdd.ElapsedMilliseconds);
Console.WriteLine("Remove = {0}", swRemove.ElapsedMilliseconds);
Console.WriteLine("ContainsKey = {0}", swContainsKey.ElapsedMilliseconds);
//skipList.Add(10, "tralala");
//skipList.Add(20, "tutu");
//skipList.Add(20, "pouet");
//Console.WriteLine("Contains 10 = {0}", skipList.ContainsKey(10));
//Console.WriteLine("Contains 20 = {0}", skipList.ContainsKey(20));
//Console.WriteLine("Remove 20 = {0}", skipList.Remove(20));
//Console.WriteLine("Remove 10 = {0}", skipList.Remove(10));
//Console.WriteLine("Remove 20 = {0}", skipList.Remove(20));
//Console.WriteLine("Contains 20 = {0}", skipList.ContainsKey(20));
//Console.WriteLine("Contains 10 = {0}", skipList.ContainsKey(10));
}
public void Simple()
{
var skipList = new SkipList<int, string>();
var pairs = new KeyValuePair<int, string>[5];
for (var i = 0; i < pairs.Length; i++)
{
pairs[i] = new KeyValuePair<int, string>(i, i.ToString());
skipList.Add(pairs[i]);
}
var array = new KeyValuePair<int, string>[50];
skipList.CopyTo(array, 0);
var list = new List<KeyValuePair<int, string>>
{
array[0],
array[1],
array[2],
array[3],
array[4],
array[5]
};
foreach (var keyValuePair in pairs)
{
Assert.IsTrue(list.Contains(keyValuePair));
}
}
public void Reverse()
{
var skipList = new SkipList<int, string>();
var counter = 0;
for (var i = 499; i >= 0; i--)
{
if ((i % 2) == 0)
{
skipList.Add(i, i.ToString());
}
else
{
skipList.Add(new KeyValuePair<int, string>(i, i.ToString()));
}
counter++;
Assert.AreEqual(skipList.Count, counter);
Assert.AreEqual(skipList[i], i.ToString());
}
}
public static void DoTest()
{
var skipList = new SkipList<int>();
skipList.Add(20);
skipList.Add(10);
skipList.Add(5);
skipList.Add(11);
skipList.Add(1);
// Get enumarator
var enumerator = skipList.GetEnumerator();
Console.WriteLine(" [*] Skip-List elements:");
Console.Write("..... ");
while (enumerator.MoveNext())
Console.Write("{0} -> ", enumerator.Current);
Console.WriteLine("\r\n===================================\r\n");
int min = default(int);
if (skipList.TryDeleteMin(out min))
Console.WriteLine("Removed min from SkipList, and it was: {0}", min);
Console.WriteLine("\r\n===================================\r\n");
// Reload enumarator
enumerator = skipList.GetEnumerator();
Console.WriteLine(" [*] Skip-List elements:");
Console.Write("..... ");
while (enumerator.MoveNext())
Console.Write("{0} -> ", enumerator.Current);
Console.WriteLine("\r\n===================================\r\n");
skipList.Clear();
for (int i = 100; i >= 50; --i)
skipList.Add(i);
for (int i = 0; i <= 35; ++i)
skipList.Add(i);
// Reload enumarator
enumerator = skipList.GetEnumerator();
Console.WriteLine(" [*] Skip-List elements:");
Console.Write("..... ");
while (enumerator.MoveNext())
Console.Write("{0} -> ", enumerator.Current);
Console.WriteLine("\r\nSkipList Count = {0}", skipList.Count);
Console.WriteLine("\r\n===================================\r\n");
for (int i = -15; i <= 0; ++i)
skipList.Add(i);
for (int i = -15; i >= -35; --i)
skipList.Add(i);
// Reload enumarator
enumerator = skipList.GetEnumerator();
Console.WriteLine(" [*] Skip-List elements:");
Console.Write("..... ");
while (enumerator.MoveNext())
Console.Write("{0} -> ", enumerator.Current);
Debug.Assert(skipList.Count == 124);
Console.WriteLine("\r\nSkipList Count = {0}", skipList.Count);
Console.WriteLine("\r\n===================================\r\n");
skipList.Clear();
for (int i = 100; i >= 0; --i)
skipList.Add(i);
// Reload enumarator
enumerator = skipList.GetEnumerator();
Console.WriteLine(" [*] Skip-List elements:");
Console.Write("..... ");
while (enumerator.MoveNext())
Console.Write("{0} -> ", enumerator.Current);
Debug.Assert(skipList.Count == 101);
Console.WriteLine("\r\nSkipList Count = {0}", skipList.Count);
Console.WriteLine("\r\n===================================\r\n");
Console.ReadLine();
}
public void Sequential()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 500; i++)
{
if ((i % 2) == 0)
{
skipList.Add(i, i.ToString());
}
else
{
skipList.Add(new KeyValuePair<int, string>(i, i.ToString()));
}
Assert.AreEqual(skipList.Count, i + 1);
Assert.AreEqual(skipList[i], i.ToString());
}
}
