public void TestPut_Int_1()
{
PowerSet <int> ps1 = new PowerSet <int>();
Assert.AreEqual(0, ps1.Size());
ps1.Put(1);
ps1.Put(2);
ps1.Put(3);
ps1.Put(6);
Assert.AreEqual(4, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
Assert.AreEqual(true, ps1.Get(2));
Assert.AreEqual(true, ps1.Get(3));
Assert.AreEqual(true, ps1.Get(6));
Assert.AreEqual(false, ps1.Get(5));
ps1.Put(5);
Assert.AreEqual(5, ps1.Size());
Assert.AreEqual(true, ps1.Get(5));
}
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 TestEBit_4()
{
PowerSet <int> ps1 = new PowerSet <int>();
ps1.Put(1);
ps1.Put(83);
ps1.Put(923);
ps1.Put(44);
ps1.Put(9410);
ps1.Put(642);
ps1.Put(5);
Assert.AreEqual(7, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
Assert.AreEqual(true, ps1.Get(83));
Assert.AreEqual(true, ps1.Get(923));
Assert.AreEqual(true, ps1.Get(44));
Assert.AreEqual(true, ps1.Get(9410));
Assert.AreEqual(true, ps1.Get(642));
Assert.AreEqual(true, ps1.Get(5));
ps1.Remove(83);
Assert.AreEqual(6, ps1.Size());
Assert.AreEqual(true, ps1.Get(1));
Assert.AreEqual(false, ps1.Get(83));
Assert.AreEqual(true, ps1.Get(923));
Assert.AreEqual(true, ps1.Get(44));
Assert.AreEqual(true, ps1.Get(9410));
Assert.AreEqual(true, ps1.Get(642));
Assert.AreEqual(true, ps1.Get(5));
}
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));
}
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 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 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 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 Put_if_Set_Already_Has_This_Elem()
{
PowerSet <string> strSet = new PowerSet <string>();
strSet.Put("word");
Assert.IsTrue(strSet.Size() == 1);
Assert.IsTrue(strSet.Get("word"));
strSet.Put("word");
Assert.IsTrue(strSet.Size() == 1);
}
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 TestPut_Int_4()
{
PowerSet <int> ps1 = new PowerSet <int>();
ps1.Put(3);
ps1.Put(32);
ps1.Put(321);
Assert.AreEqual(3, ps1.Size());
ps1.Put(3);
ps1.Put(32);
Assert.AreEqual(3, ps1.Size());
}
public void TestPut_Char_4()
{
PowerSet <char> ps1 = new PowerSet <char>();
ps1.Put(' ');
ps1.Put('5');
ps1.Put('a');
Assert.AreEqual(3, ps1.Size());
ps1.Put('5');
ps1.Put('a');
Assert.AreEqual(3, ps1.Size());
}
public void TestPut_String_4()
{
PowerSet <string> ps1 = new PowerSet <string>();
ps1.Put("word");
ps1.Put("string");
ps1.Put("chars");
Assert.AreEqual(3, ps1.Size());
ps1.Put("word");
ps1.Put("string");
Assert.AreEqual(3, ps1.Size());
}
public void TestPut_Float_4()
{
PowerSet <float> ps1 = new PowerSet <float>();
ps1.Put(0.3f);
ps1.Put(3.2f);
ps1.Put(32.1f);
Assert.AreEqual(3, ps1.Size());
ps1.Put(3.2f);
ps1.Put(32.1f);
Assert.AreEqual(3, ps1.Size());
}
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 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 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 Subset_if_One_Set_Includes_Second_Set_Incompletely()
{
PowerSet <int> testSet = new PowerSet <int>();
testSet.Put(1);
testSet.Put(2);
testSet.Put(3);
testSet.Put(4);
testSet.Put(5);
testSet.Put(6);
PowerSet <int> set2 = new PowerSet <int>();
set2.Put(1);
set2.Put(3);
set2.Put(4);
set2.Put(5);
set2.Put(6);
set2.Put(7);
bool isSubset = testSet.IsSubset(set2);
Assert.IsTrue(testSet.Size() == 6);
Assert.IsFalse(isSubset);
Assert.IsTrue(set2.Size() == 6);
}
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 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 PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
var currValues = WhereIsNotNull(slots);
var set2Values = WhereIsNotNull(set2.slots);
var result = new PowerSet <T>(base.Size() + set2.Size());
foreach (var currValue in currValues)
{
var obj = (T)Convert.ChangeType(currValue, typeof(T));
result.Put(obj);
var status = Get_Put_status();
if (status != PUT_OK || status != PUT_ALREADYHAS)
{
union_status = UNION_ERR;
return(result);
}
}
foreach (var value in set2Values)
{
var obj = (T)Convert.ChangeType(value, typeof(T));
result.Put(obj);
var status = Get_Put_status();
if (status != PUT_OK || status != PUT_ALREADYHAS)
{
union_status = UNION_ERR;
return(result);
}
}
union_status = UNION_OK;
return(result);
}
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_Char_3A()
{
PowerSet <char> ps1 = new PowerSet <char>();
ps1.Put(' ');
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(' '));
}
public void Intersection_Is_Both_Sets_has_not_values()
{
PowerSet <int> testSet = new PowerSet <int>();
PowerSet <int> set2 = new PowerSet <int>();
PowerSet <int> interSet = testSet.Intersection(set2);
Assert.IsTrue(interSet.Size() == 0);
}
public void Difference_Both_Sets_Are_Empty()
{
PowerSet <int> testSet = new PowerSet <int>();
PowerSet <int> set2 = new PowerSet <int>();
PowerSet <int> interSet = testSet.Difference(set2);
Assert.IsTrue(interSet.Size() == 0);
}
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 Remove_if_Set_Is_Empty()
{
PowerSet <string> strSet = new PowerSet <string>();
bool isRemoved = strSet.Remove("Lord");
Assert.IsFalse(isRemoved);
Assert.IsTrue(strSet.Size() == 0);
}
public void Union_Both_Sets_Are_Empty()
{
PowerSet <int> testSet = new PowerSet <int>();
PowerSet <int> set2 = new PowerSet <int>();
PowerSet <int> interSet = testSet.Union(set2);
Assert.IsTrue(interSet.Size() == 0);
}
public void PutTest()
{
PowerSet <int> set = new PowerSet <int>();
set.Put(1);
set.Put(1);
set.Put(2);
Assert.True(set.Size() == 2);
}
public void Test_Put_WhenSameValue()
{
var set = new PowerSet <int>();
set.Put(1);
set.Put(2);
set.Put(1);
Assert.AreEqual(2, set.Size());
}
