public void OneSetToStringTest()
{
var intSet = new Kibnet.IntSet();
intSet.Add(1);
foreach (int indexCard0 in intSet.root)
{
var card0 = intSet.root.Cards[indexCard0];
Assert.Equal("1000000000000000000000000000000000000000000000000000000000000000", card0.ToString());
foreach (int indexCard1 in card0)
{
var card1 = card0.Cards[indexCard1];
Assert.Equal("1000000000000000000000000000000000000000000000000000000000000000", card1.ToString());
foreach (int indexCard2 in card1)
{
var card2 = card1.Cards[indexCard2];
Assert.Equal("1000000000000000000000000000000000000000000000000000000000000000", card2.ToString());
foreach (int indexCard3 in card2)
{
var card3 = card2.Cards[indexCard3];
Assert.Equal("0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", card3.ToString());
foreach (byte byteValue in card3)
{
Assert.Equal("2", byteValue.ToString());
break;
}
}
}
}
}
}
public void IterationDeleteTest(int from, int to)
{
var intSet = new Kibnet.IntSet();
for (int i = from; i < to; i++)
{
intSet.Add(i);
}
for (int i = from; i < to; i++)
{
Assert.True(intSet.Contains(i));
intSet.Remove(i);
for (int j = from; j < to; j++)
{
if (i >= j)
{
Assert.False(intSet.Contains(j));
}
else
{
Assert.True(intSet.Contains(j));
}
}
}
}
public void FullSetToStringTest()
{
var intSet = new Kibnet.IntSet(false, true);
var rootString = intSet.root.ToString();
Assert.Equal("1111111111111111111111111111111111111111111111111111111111111111", rootString);
}
public void BoundContainsTest(int value)
{
var intSet = new Kibnet.IntSet();
{
intSet.Add(value);
}
Assert.True(intSet.Contains(value));
}
public void EmptySetTest(int from, int to)
{
var intSet = new Kibnet.IntSet();
foreach (var i in TestHelper.GetEnumerable(from, to))
{
Assert.False(intSet.Contains(i));
}
}
public void ExceptWithTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 100));
var intSet2 = new Kibnet.IntSet(TestHelper.GetEnumerable(10000, 0));
intSet.ExceptWith(intSet2);
intSet.EqualRange(10001, 100000);
}
public void FullSetTest(int from, int to)
{
var intSet = new Kibnet.IntSet(false, true);
intSet.Add(0);
foreach (var i in TestHelper.GetEnumerable(from, to))
{
Assert.True(intSet.Contains(i));
}
}
public void IsProperSubsetOfIEnumerableTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 100));
var intSet2 = TestHelper.GetEnumerable(10000, 0);
var intSet3 = TestHelper.GetEnumerable(100000, 0);
Assert.False(intSet.IsProperSubsetOf(intSet2));
Assert.True(intSet.IsProperSubsetOf(intSet3));
}
public void OrderedEnumerateTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 0));
var last = -1;
foreach (var i in intSet)
{
Assert.Equal(last + 1, i);
last = i;
}
}
public void SimpleDeleteTest()
{
var intSet = new Kibnet.IntSet();
for (int i = 100000; i < 200000; i++)
{
intSet.Add(i);
Assert.True(intSet.Contains(i));
intSet.Remove(i);
Assert.False(intSet.Contains(i));
}
}
public void Card0FullTest()
{
var intSet = new Kibnet.IntSet();
intSet.Add(0);
var card0 = intSet.root.Cards.FirstOrDefault(card => card != null);
card0.Full = true;
card0.Cards = null;
intSet.Add(0);
Assert.True(intSet.Contains(0));
}
public void OrderedIEnumerateTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 0));
var last = -1;
var enumerable = intSet as IEnumerable;
foreach (int i in enumerable)
{
Assert.Equal(last + 1, i);
last = i;
}
}
public void FullEnumeratorTest()
{
var intSet = new Kibnet.IntSet(false, true);
var last = -1;
foreach (var i in intSet.Take(100000))
{
Assert.Equal(last + 1, i);
Assert.True(intSet.Contains(i));
last = i;
}
}
public static void EqualRange(this Kibnet.IntSet intSet, int start, int finish)
{
var enumerable = intSet as IEnumerable;
var last = start - 1;
Assert.Equal(start, intSet.First());
foreach (int i in enumerable)
{
Assert.Equal(last + 1, i);
last = i;
}
Assert.Equal(finish, intSet.Last());
}
public void SimpleContainsTest()
{
var intSet = new Kibnet.IntSet();
for (int i = 0; i < 100000; i++)
{
intSet.Add(i);
}
for (int i = 0; i < 100000; i++)
{
Assert.True(intSet.Contains(i));
}
for (int i = 100000; i < 200000; i++)
{
Assert.False(intSet.Contains(i));
}
}
public void CopyToTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 1));
var array = new int[intSet.Count];
intSet.CopyTo(array);
var last = 0;
Assert.Equal(1, intSet.First());
foreach (int i in array)
{
Assert.Equal(last + 1, i);
last = i;
}
Assert.Equal(100000, intSet.Last());
}
public void IntersectWithIEnumerableTest()
{
var intSet = new Kibnet.IntSet(TestHelper.GetEnumerable(100000, 100));
var intSet2 = TestHelper.GetEnumerable(10000, 0);
intSet.IntersectWith(intSet2);
var last = 99;
var enumerable = intSet as IEnumerable;
Assert.Equal(100, intSet.First());
foreach (int i in enumerable)
{
Assert.Equal(last + 1, i);
last = i;
}
Assert.Equal(10000, intSet.Last());
}
public void NotEvensTest(int from, int to)
{
var intSet = new Kibnet.IntSet();
foreach (var i in TestHelper.GetEnumerable(from, to))
{
if (i % 2 != 0)
{
intSet.Add(i);
}
}
foreach (var i in TestHelper.GetEnumerable(from, to))
{
if (i % 2 != 0)
{
Assert.True(intSet.Contains(i));
}
else
{
Assert.False(intSet.Contains(i));
}
}
}
