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 GetFromEmpty()
{
PowerSet <int> set = new PowerSet <int>();
Assert.True(set.Get(1) == false);
Assert.True(set.Get(0) == false);
}
public void SizeTest()
{
PowerSet <string> s1 = new PowerSet <string>();
if (s1.Size() != 0)
{
Assert.Fail();
}
s1.Put("erer");
if (s1.Size() != 1)
{
Assert.Fail();
}
s1.Put("erer");
if (s1.Size() != 1)
{
Assert.Fail();
}
s1.Put("erere");
if (s1.Size() != 2)
{
Assert.Fail();
}
s1.Put("serer");
s1.Put("erer");
if (s1.Size() != 3)
{
Assert.Fail();
}
s1.Remove("erer");
if (s1.Size() != 2)
{
Assert.Fail();
}
}
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 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 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 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 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 void TestUnion_Int_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 10000; i++)
{
ps1.Put(i);
}
for (int i = 9981; i <= 20000; i++)
{
ps2.Put(i);
}
ps3 = ps1.Union(ps2);
Assert.AreEqual(20000, ps3.Size());
for (int i = 1; i <= 20000; i++)
{
Assert.AreEqual(true, ps3.Get(i));
}
}
public void TestUnion_Int_3B()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 5; i++)
{
ps1.Put(i);
}
ps3 = ps1.Union(ps2);
Assert.AreEqual(5, ps3.Size());
for (int i = 1; i < 10; i++)
{
if (i < 6)
{
Assert.AreEqual(true, ps3.Get(i));
}
else
{
Assert.AreEqual(false, ps3.Get(i));
}
}
}
public void TestDifference_Int_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 10000; i++)
{
ps1.Put(i);
}
for (int i = 9981; i <= 20000; i++)
{
ps2.Put(i);
}
ps3 = ps1.Difference(ps2);
Assert.AreEqual(9980, ps3.Size());
for (int i = 1; i <= 19980; i++)
{
if (i < 9981)
{
Assert.AreEqual(true, ps3.Get(i));
}
else
{
Assert.AreEqual(false, ps3.Get(i));
}
}
}
public void TestDifference_Int_3A()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 5; i++)
{
ps1.Put(i);
}
for (int i = 7; i <= 11; i++)
{
ps2.Put(i);
}
ps3 = ps1.Difference(ps2);
Assert.AreEqual(5, ps3.Size());
for (int i = 1; i <= 11; i++)
{
if (!(i > 5))
{
Assert.AreEqual(true, ps3.Get(i));
}
else
{
Assert.AreEqual(false, ps3.Get(i));
}
}
}
public void TestIntersection_Node_2()
{
PowerSet <Node> ps1 = new PowerSet <Node>();
PowerSet <Node> ps2 = new PowerSet <Node>();
PowerSet <Node> ps3;
Node[] nodes = new Node[39980];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = new Node(i);
}
for (int i = 0; i < 20000; i++)
{
ps1.Put(nodes[i]);
}
for (int i = 19980; i < 39980; i++)
{
ps2.Put(nodes[i]);
}
ps3 = ps1.Intersection(ps2);
Assert.AreEqual(20, ps3.Size());
for (int i = 19980; i < 20000; i++)
{
Assert.AreEqual(true, ps3.Get(nodes[i]));
}
}
public void TestDifference_Int_1A()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 10; i++)
{
ps1.Put(i);
}
ps2.Put(3);
ps2.Put(6);
ps2.Put(7);
ps2.Put(10);
ps3 = ps1.Difference(ps2);
Assert.AreEqual(6, ps3.Size());
Assert.AreEqual(true, ps3.Get(1));
Assert.AreEqual(true, ps3.Get(2));
Assert.AreEqual(true, ps3.Get(4));
Assert.AreEqual(true, ps3.Get(5));
Assert.AreEqual(true, ps3.Get(8));
Assert.AreEqual(true, ps3.Get(9));
Assert.AreEqual(false, ps3.Get(3));
Assert.AreEqual(false, ps3.Get(6));
Assert.AreEqual(false, ps3.Get(7));
Assert.AreEqual(false, ps3.Get(10));
for (int i = 11; i < 20000; i++)
{
Assert.AreEqual(false, ps3.Get(i));
}
}
public void TestIntersection_String_2()
{
PowerSet <string> ps1 = new PowerSet <string>();
PowerSet <string> ps2 = new PowerSet <string>();
PowerSet <string> ps3;
for (int i = 1; i <= 20000; i++)
{
ps1.Put("" + i);
}
for (int i = 19981; i <= 39980; i++)
{
ps2.Put("" + i);
}
ps3 = ps1.Intersection(ps2);
for (int i = 19981; i <= 20000; i++)
{
Assert.AreEqual(true, ps3.Get("" + i));
}
Assert.AreEqual(20, ps3.Size());
Assert.AreEqual(false, ps3.Get("f"));
Assert.AreEqual(false, ps3.Get("222"));
}
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 TestIntersection_String_1()
{
PowerSet <string> ps1 = new PowerSet <string>();
PowerSet <string> ps2 = new PowerSet <string>();
PowerSet <string> ps3;
for (int i = 1; i <= 5; i++)
{
ps1.Put("" + i);
}
for (int i = 3; i <= 7; i++)
{
ps2.Put("" + i);
}
ps3 = ps1.Intersection(ps2);
for (int i = 3; i <= 5; i++)
{
Assert.AreEqual(true, ps3.Get("" + i));
}
Assert.AreEqual(3, ps3.Size());
Assert.AreEqual(false, ps3.Get("1"));
Assert.AreEqual(false, ps3.Get("33"));
}
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 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);
}
private PowerSet ReadPowerSet()
{
var powerSet = new PowerSet();
powerSet.FullName = _reader.ReadString();
return(powerSet);
}
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 TestIntersection_Char_1()
{
PowerSet <char> ps1 = new PowerSet <char>();
PowerSet <char> ps2 = new PowerSet <char>();
PowerSet <char> ps3;
for (int i = 1; i <= 20000; i++)
{
ps1.Put(Convert.ToChar(i));
}
for (int i = 19981; i <= 39980; i++)
{
ps2.Put(Convert.ToChar(i));
}
ps3 = ps1.Intersection(ps2);
for (int i = 19981; i <= 20000; i++)
{
Assert.AreEqual(true, ps3.Get(Convert.ToChar(i)));
}
Assert.AreEqual(20, ps3.Size());
Assert.AreEqual(false, ps3.Get(Convert.ToChar(30382)));
Assert.AreEqual(false, ps3.Get(Convert.ToChar(10382)));
}
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 TestIntersection_Int_2()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 20000; i++)
{
ps1.Put(i);
}
for (int i = 19981; i <= 39980; i++)
{
ps2.Put(i);
}
ps3 = ps1.Intersection(ps2);
for (int i = 19981; i <= 20000; i++)
{
Assert.AreEqual(true, ps3.Get(i));
}
Assert.AreEqual(20, ps3.Size());
Assert.AreEqual(false, ps3.Get(20005));
Assert.AreEqual(false, ps3.Get(16050));
}
public void TestIntersection_Int_1()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
PowerSet <int> ps3;
for (int i = 1; i <= 5; i++)
{
ps1.Put(i);
}
for (int i = 3; i <= 7; i++)
{
ps2.Put(i);
}
ps3 = ps1.Intersection(ps2);
for (int i = 3; i <= 5; i++)
{
Assert.AreEqual(true, ps3.Get(i));
}
Assert.AreEqual(3, ps3.Size());
Assert.AreEqual(false, ps3.Get(6));
Assert.AreEqual(false, ps3.Get(2));
}
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 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_Char_3A()
{
PowerSet <char> ps1 = new PowerSet <char>();
ps1.Put(' ');
Assert.AreEqual(1, ps1.Size());
Assert.AreEqual(true, ps1.Get(' '));
}
public void TestBitTest_1()
{
PowerSet <float> ps2 = new PowerSet <float>();
ps2.Remove(2.01f);
ps2.Remove(51.79f);
ps2.Remove(910536.5353f);
ps2.Put(910536.5353f);
}
public void Works_with_0_items()
{
var sut = new PowerSet<string>(new string[0]);
GenerateOutput(sut);
AreEqual(GetExpectedTestOutput(), GetActualTestOutput());
}
public void Works_with_5_items()
{
var sut = new PowerSet<string>(new[] { "a", "b", "c", "d", "e" });
GenerateOutput(sut);
AreEqual(GetExpectedTestOutput(), GetActualTestOutput());
}
