public void RemoveTest()
{
PowerSet <int> set = new PowerSet <int>();
set.Put(1);
set.Put(1);
set.Put(2);
set.Put(2);
set.Put(3);
Assert.True(set.Size() == 3);
Assert.True(set.Get(1));
Assert.True(set.Get(2));
Assert.True(set.Get(3));
Assert.True(!set.Get(4));
Assert.True(set.Remove(3));
Assert.True(set.Size() == 2);
Assert.True(set.Get(1));
Assert.True(set.Get(2));
Assert.True(!set.Get(3));
Assert.True(set.Remove(2));
Assert.True(set.Size() == 1);
Assert.True(set.Get(1));
Assert.True(!set.Get(2));
Assert.True(!set.Get(3));
Assert.True(!set.Remove(2));
Assert.True(!set.Remove(3));
}
public void TestEPut_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
int n1 = 52;
int n2 = 174;
int n3 = 9;
Assert.AreEqual(0, ps1.Size());
ps1.Put(n1);
ps1.Put(n2);
ps1.Put(n3);
Assert.AreEqual(true, ps1.Get(n1));
Assert.AreEqual(true, ps1.Get(n2));
Assert.AreEqual(true, ps1.Get(n3));
Assert.AreEqual(3, ps1.Size());
ps1.Put(9);
Assert.AreEqual(3, ps1.Size());
for (int i = 200; i < 300; i++)
{
ps1.Put(i);
}
Assert.AreEqual(103, ps1.Size());
for (int i = 200; i < 300; i++)
{
Assert.AreEqual(true, ps1.Get(i));
}
}
public void GetFromEmpty()
{
PowerSet <int> set = new PowerSet <int>();
Assert.True(set.Get(1) == false);
Assert.True(set.Get(0) == false);
}
public static void TestsPowerSetDifference()
{
var testPowerSet1 = new PowerSet <int>();
var testPowerSet2 = new PowerSet <int>();
Assert.AreEqual(0, testPowerSet1.Size());
Assert.AreEqual(0, testPowerSet2.Size());
testPowerSet1.Put(1);
Assert.AreEqual(1, testPowerSet1.Size());
Assert.IsTrue(testPowerSet1.Get(1));
testPowerSet1.Put(2);
Assert.AreEqual(2, testPowerSet1.Size());
Assert.IsTrue(testPowerSet1.Get(1));
Assert.IsTrue(testPowerSet1.Get(2));
testPowerSet1.Put(3);
Assert.AreEqual(3, testPowerSet1.Size());
Assert.IsTrue(testPowerSet1.Get(1));
Assert.IsTrue(testPowerSet1.Get(2));
Assert.IsTrue(testPowerSet1.Get(3));
testPowerSet2.Put(1);
Assert.AreEqual(1, testPowerSet2.Size());
Assert.IsTrue(testPowerSet2.Get(1));
testPowerSet2.Put(3);
Assert.AreEqual(2, testPowerSet2.Size());
Assert.IsTrue(testPowerSet2.Get(1));
Assert.IsTrue(testPowerSet2.Get(3));
var result = testPowerSet1.Difference(testPowerSet2);
Assert.AreEqual(1, result.Size());
Assert.IsTrue(result.Get(2));
}
public void TestRemove_Int_1()
{
PowerSet <int> ps1 = new PowerSet <int>();
for (int i = 1; i <= 10; i++)
{
ps1.Put(i);
}
ps1.Remove(1);
ps1.Remove(2);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
ps1.Remove(0);
Assert.AreEqual(8, ps1.Size());
Assert.AreEqual(true, ps1.Get(3));
Assert.AreEqual(true, ps1.Get(4));
Assert.AreEqual(true, ps1.Get(0));
Assert.AreEqual(false, ps1.Get(1));
Assert.AreEqual(false, ps1.Get(2));
}
public void TestEBit_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <string> ps3 = new PowerSet <string>();
PowerSet <string> ps4 = new PowerSet <string>();
ps1.Put(1);
ps1.Put(83);
ps1.Put(923);
ps1.Put(44);
ps1.Put(9410);
ps1.Put(642);
ps1.Put(5);
ps2.Put(3);
ps2.Put(5);
ps2.Put(44);
ps2.Put(187);
ps2.Put(500);
ps2.Put(923);
ps2.Put(601);
PowerSet <int> psi = ps1.Intersection(ps2);
Assert.AreEqual(true, psi.Get(5));
Assert.AreEqual(true, psi.Get(923));
Assert.AreEqual(true, psi.Get(44));
}
public void Test_Get_WhenValueExists()
{
var set = new PowerSet <string>();
set.Put("a");
set.Put("b");
set.Put("a");
Assert.AreEqual(true, set.Get("b"));
Assert.AreEqual(false, set.Get("k"));
}
public void TestPut_Char_2()
{
PowerSet <char> ps1 = new PowerSet <char>();
for (int i = 1; i <= 20000; i++)
{
Assert.AreEqual(false, ps1.Get(Convert.ToChar(i)));
ps1.Put(Convert.ToChar(i));
Assert.AreEqual(true, ps1.Get(Convert.ToChar(i)));
}
}
public void Union_both_Sets_has_values()
{
PowerSet <int> testSet = new PowerSet <int>();
testSet.Put(1);
testSet.Put(2);
testSet.Put(3);
testSet.Put(4);
PowerSet <int> set2 = new PowerSet <int>();
set2.Put(5);
set2.Put(6);
set2.Put(7);
set2.Put(8);
PowerSet <int> interSet = testSet.Union(set2);
Assert.IsTrue(interSet.Size() == 8);
Assert.IsTrue(interSet.Get(1));
Assert.IsTrue(interSet.Get(2));
Assert.IsTrue(interSet.Get(3));
Assert.IsTrue(interSet.Get(4));
Assert.IsTrue(interSet.Get(5));
Assert.IsTrue(interSet.Get(6));
Assert.IsTrue(interSet.Get(7));
Assert.IsTrue(interSet.Get(8));
}
public void TestPut_String_1()
{
PowerSet <string> ps1 = new PowerSet <string>();
ps1.Put("bullet");
ps1.Put("scarlet");
ps1.Put("parrot");
ps1.Put("Pop");
ps1.Put("soap");
Assert.AreEqual(5, ps1.Size());
Assert.AreEqual(true, ps1.Get("bullet"));
Assert.AreEqual(true, ps1.Get("scarlet"));
Assert.AreEqual(true, ps1.Get("parrot"));
Assert.AreEqual(true, ps1.Get("soap"));
Assert.AreEqual(true, ps1.Get("Pop"));
Assert.AreEqual(false, ps1.Get("pop"));
Assert.AreEqual(false, ps1.Get("quatro"));
ps1.Put("quatro");
Assert.AreEqual(6, ps1.Size());
Assert.AreEqual(true, ps1.Get("quatro"));
}
public void TestPut_String_3()
{
PowerSet <string> ps1 = new PowerSet <string>();
Assert.AreEqual(0, ps1.Size());
ps1.Put("");
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(""));
ps1.Put(" ");
Assert.AreEqual(2, ps1.Size());
Assert.AreEqual(true, ps1.Get(" "));
}
public void TestEUnion_1()
{
PowerSet <string> ps1 = new PowerSet <string>();
PowerSet <string> ps2 = new PowerSet <string>();
ps1.Put("j1");
ps1.Put("j2");
ps1.Put("car");
ps1.Put("far");
ps2.Put("Pop");
ps2.Put("far");
ps2.Put("j2");
ps2.Put("trust");
ps2.Put("bleach");
Assert.AreEqual(4, ps1.Size());
Assert.AreEqual(5, ps2.Size());
PowerSet <string> ps3 = ps1.Union(ps2);
Assert.AreEqual(7, ps3.Size());
Assert.AreEqual(true, ps3.Get("far"));
Assert.AreEqual(true, ps3.Get("j2"));
Assert.AreEqual(true, ps3.Get("car"));
Assert.AreEqual(true, ps3.Get("j1"));
Assert.AreEqual(true, ps3.Get("Pop"));
Assert.AreEqual(true, ps3.Get("trust"));
Assert.AreEqual(true, ps3.Get("bleach"));
Assert.AreEqual(false, ps3.Get("forest"));
}
public void TestPut_Int_3()
{
PowerSet <int> ps1 = new PowerSet <int>();
ps1.Put(0);
Assert.AreEqual(0, ps1.Size());
Assert.AreEqual(true, ps1.Get(0));
ps1.Put(1);
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
ps1.Put(0);
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
}
public void TestPut_Float_3()
{
PowerSet <float> ps1 = new PowerSet <float>();
ps1.Put(0.0f);
Assert.AreEqual(0, ps1.Size());
Assert.AreEqual(true, ps1.Get(0.0f));
ps1.Put(1.1f);
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(1.1f));
ps1.Put(0);
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(1.1f));
}
public void GeneralTestusingCount()
{
PowerSet <int> iii = new PowerSet <int>();
iii.Put(10);
if (iii.Size() != 1)
{
Assert.Fail();
}
iii.Put(10);
if (iii.Size() != 1)
{
Assert.Fail();
}
iii.Put(20);
if (iii.Size() != 2)
{
Assert.Fail();
}
iii.Remove(10);
if (iii.Size() != 1)
{
Assert.Fail();
}
if (!iii.Get(20))
{
Assert.Fail();
}
}
public void Test_Remove_WhenValueDoesntExist()
{
// возвращает true если value удалено
// иначе false
var set = new PowerSet <int>();
set.Put(1);
set.Put(2);
set.Put(1);
var result = set.Remove(3);
Assert.AreEqual(false, result);
Assert.AreEqual(true, set.Get(1));
Assert.AreEqual(true, set.Get(2));
Assert.AreEqual(2, set.Size());
}
public void TestPut_Char_3A()
{
PowerSet <char> ps1 = new PowerSet <char>();
ps1.Put(' ');
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(' '));
}
public static void TestsPowerSetPut()
{
var testPowerSet = new PowerSet <int>();
Assert.AreEqual(0, testPowerSet.Size());
testPowerSet.Put(1);
Assert.AreEqual(1, testPowerSet.Size());
Assert.IsTrue(testPowerSet.Get(1));
testPowerSet.Put(2);
Assert.AreEqual(2, testPowerSet.Size());
Assert.IsTrue(testPowerSet.Get(1));
Assert.IsTrue(testPowerSet.Get(2));
testPowerSet.Put(1);
Assert.AreEqual(2, testPowerSet.Size());
Assert.IsTrue(testPowerSet.Get(1));
Assert.IsTrue(testPowerSet.Get(2));
}
public void TestPut_String_2()
{
PowerSet <string> ps1 = new PowerSet <string>();
for (float i = 1; i <= 20000.0f; i++)
{
Assert.AreEqual(false, ps1.Get("" + i));
ps1.Put("" + i);
Assert.AreEqual(true, ps1.Get("" + i));
}
Assert.AreEqual(20000, ps1.Size());
for (float i = 1; i <= 20000.0f; i++)
{
Assert.AreEqual(true, ps1.Get("" + i));
}
}
public void Put_in_Empty_Set()
{
PowerSet <string> strSet = new PowerSet <string>();
strSet.Put("word");
Assert.IsTrue(strSet.Size() == 1);
Assert.IsTrue(strSet.Get("word"));
}
public void Test_Remove_WhenValueExists()
{
// возвращает true если value удалено
// иначе false
var set = new PowerSet <string>();
set.Put("a");
set.Put("b");
set.Put("a");
var result = set.Remove("a");
Assert.AreEqual(true, result);
Assert.AreEqual(false, set.Get("a"));
Assert.AreEqual(true, set.Get("b"));
Assert.AreEqual(false, set.Get("k"));
Assert.AreEqual(1, set.Size());
}
public void TestPut_Int_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
for (int i = 1; i <= 20000; i++)
{
Assert.AreEqual(false, ps1.Get(i));
ps1.Put(i);
Assert.AreEqual(true, ps1.Get(i));
}
Assert.AreEqual(20000, ps1.Size());
for (int i = 1; i <= 20000; i++)
{
Assert.AreEqual(true, ps1.Get(i));
}
}
public void Union_if_One_Set_is_Empty()
{
PowerSet <int> testSet = new PowerSet <int>();
PowerSet <int> set2 = new PowerSet <int>();
set2.Put(1);
set2.Put(2);
set2.Put(3);
set2.Put(4);
PowerSet <int> interSet = testSet.Union(set2);
Assert.IsTrue(interSet.Size() == 4);
Assert.IsTrue(interSet.Get(1));
Assert.IsTrue(interSet.Get(2));
Assert.IsTrue(interSet.Get(3));
Assert.IsTrue(interSet.Get(4));
}
public void Test_Get_WhenNoValue()
{
var set = new PowerSet <int>();
set.Put(1);
set.Put(2);
set.Put(1);
Assert.AreEqual(false, set.Get(3));
}
public void TestEPut_4()
{
PowerSet <bool> ps1 = new PowerSet <bool>();
bool b1 = false;
bool b2 = true;
bool b3 = true;
Assert.AreEqual(0, ps1.Size());
ps1.Put(b1);
ps1.Put(b2);
ps1.Put(b3); // не добавляет
Assert.AreEqual(true, ps1.Get(b1));
Assert.AreEqual(true, ps1.Get(b2));
Assert.AreEqual(true, ps1.Get(b3)); // обнаруживает тот же слот что и b2
Assert.AreEqual(true, ps1.Get(false));
Assert.AreEqual(1, ps1.Size());
}
public void TestPut_Int_5()
{
PowerSet <int> ps1 = new PowerSet <int>();
for (int i = 0; i < 20000; i++)
{
ps1.Put(i);
}
Assert.AreEqual(19999, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
}
public void Put_Several_Values_in_Set()
{
PowerSet <string> strSet = new PowerSet <string>();
strSet.Put("word");
Assert.IsTrue(strSet.Size() == 1);
strSet.Put("Lord");
Assert.IsTrue(strSet.Size() == 2);
strSet.Put("cord");
Assert.IsTrue(strSet.Size() == 3);
Assert.IsTrue(strSet.Get("word"));
Assert.IsTrue(strSet.Get("Lord"));
Assert.IsTrue(strSet.Get("cord"));
Assert.IsFalse(strSet.Get("lord"));
}
public void TestRemove_String_1()
{
PowerSet <string> ps1 = new PowerSet <string>();
for (int i = 1; i <= 10; i++)
{
ps1.Put("" + i);
}
ps1.Remove("");
ps1.Remove(" ");
ps1.Remove("1");
ps1.Remove("2");
Assert.AreEqual(8, ps1.Size());
Assert.AreEqual(true, ps1.Get("3"));
Assert.AreEqual(true, ps1.Get("4"));
Assert.AreEqual(false, ps1.Get("1"));
Assert.AreEqual(false, ps1.Get("2"));
}
public void TestEIntersection_1()
{
PowerSet <string> ps1 = new PowerSet <string>();
PowerSet <string> ps2 = new PowerSet <string>();
ps1.Put("j1");
ps1.Put("j2");
ps1.Put("car");
ps1.Put("far");
ps2.Put("Pop");
ps2.Put("far");
ps2.Put("j2");
PowerSet <string> ps3 = ps1.Intersection(ps2);
Assert.AreEqual(true, ps3.Get("far"));
Assert.AreEqual(true, ps3.Get("j2"));
Assert.AreEqual(false, ps3.Get("car"));
Assert.AreEqual(2, ps3.Size());
}
public void TestPut_Node_1()
{
PowerSet <Node> ps1 = new PowerSet <Node>();
Node node1 = new Node(0);
Node node2 = new Node(1);
Node node3 = new Node(2);
Node node4 = new Node(3);
Node node5 = new Node(4);
ps1.Put(node1);
ps1.Put(node2);
ps1.Put(node3);
ps1.Put(node4);
Assert.AreEqual(4, ps1.Size());
Assert.AreEqual(true, ps1.Get(node1));
Assert.AreEqual(true, ps1.Get(node2));
Assert.AreEqual(true, ps1.Get(node3));
Assert.AreEqual(true, ps1.Get(node4));
Assert.AreEqual(false, ps1.Get(node5));
ps1.Put(node5);
Assert.AreEqual(5, ps1.Size());
Assert.AreEqual(true, ps1.Get(node5));
}
