public void TestRanges3()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"\d");
int cnt = cond.CountNodes();
Pair <uint, uint>[] ranges = solver.ToRanges(cond);
BDD set = solver.MkCharSetFromRanges(ranges);
int nodes = set.CountNodes();
var ranges2 = new List <Pair <uint, uint> >(ranges);
ranges2.Reverse();
BDD set2 = solver.MkCharSetFromRanges(ranges2);
int nodes2 = set.CountNodes();
var ranges3 = solver.ToRanges(set2);
BDD set3 = solver.MkCharSetFromRanges(ranges3);
int cnt2 = set2.CountNodes();
int cnt3 = set3.CountNodes();
Assert.IsTrue(set2 == set3);
Assert.AreEqual <int>(nodes, nodes2);
Assert.AreSame(set, set2);
set.ToDot("digits.dot");
//check equivalence
bool equiv = solver.MkOr(solver.MkAnd(cond, solver.MkNot(set)), solver.MkAnd(set, solver.MkNot(cond))) == solver.False;
Assert.AreEqual <int>(31, ranges.Length);
}
public void TestCardinality3()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"[\w-[\d]]");
int cnt = cond.CountNodes();
Pair <uint, uint>[] ranges = solver.ToRanges(cond);
BDD set = solver.MkCharSetFromRanges(ranges);
int nodes = set.CountNodes();
int size = (int)solver.ComputeDomainSize(set);
int expected = 0;
foreach (var range in ranges)
{
expected += ((int)(range.Second - range.First) + 1);
}
Assert.AreEqual <int>(expected, size);
int wCnt = 0;
for (int i = 0; i <= 0xFFFF; i++)
{
int cat = (int)char.GetUnicodeCategory((char)i);
if (cat == 0 || cat == 1 || cat == 2 || cat == 3 || cat == 4 || cat == 5 ||
cat == 8 || cat == 18) //same as \w in regex
{
if (!char.IsDigit((char)i))
{
wCnt += 1;
}
}
}
Assert.AreEqual <int>(wCnt, size);
}
public void TestCardinality()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"\d");
int cnt = cond.CountNodes();
Pair <uint, uint>[] ranges = solver.ToRanges(cond);
BDD set = solver.MkCharSetFromRanges(ranges);
int nodes = set.CountNodes();
int size = (int)solver.ComputeDomainSize(set);
int expected = 0;
foreach (var range in ranges)
{
expected += ((int)(range.Second - range.First) + 1);
}
Assert.AreEqual <int>(expected, size);
int digitCnt = 0;
for (int i = 0; i <= 0xFFFF; i++)
{
if (char.IsDigit(((char)i)))
{
digitCnt += 1;
}
}
Assert.AreEqual <int>(digitCnt, size);
}
public void TestNodeCount()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"[\x00-\u7FFF]");
int cnt = cond.CountNodes();
Assert.AreEqual <int>(3, cnt);
}
public void TestLargeRange()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"[\u0000-\u7FFF]");
int elems = (int)solver.ComputeDomainSize(cond);
int nodes = cond.CountNodes();
Assert.AreEqual <int>(3, nodes);
Assert.AreEqual <int>((1 << 15), elems);
}
public void TestShiftLeft1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft", "c:/tmp/TestShiftLeftIn.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
//BvSet bvs = solver.ShiftLeft(cond, 30);
//Assert.AreEqual<int>(5, bvs.CountNodes());
BDD bvs2 = solver.ShiftLeft(cond, 28);
Assert.AreEqual <int>(9, bvs2.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(bvs, "TestShiftLeft", "c:/tmp/TestShiftLeftOut.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestShiftRight2()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
Assert.AreEqual <int>(9, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight2.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
var sr = solver.ShiftRight(cond);
Assert.AreEqual <int>(7, sr.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(sr, "TestShiftRight", "c:/tmp/TestShiftRight2res.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestShiftRight1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond1 = solver.MkSetFromRange(0, 7, 3);
BDD cond2 = solver.MkSetFromElements(new uint[] { 9, 10, 12, 15 }, 3);
BDD cond = solver.MkOr(cond1, cond2);
Assert.AreEqual <int>(8, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight1.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD sr = solver.ShiftRight(cond);
Assert.AreEqual <BDD>(solver.True, sr);
}
public void TestShiftLeftThenRight()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft2_cond", "c:/tmp/TestShiftLeft2_cond.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD bvs = solver.ShiftLeft(cond, 4);
BDD concat = solver.MkAnd(bvs, cond);
Assert.AreEqual <int>(16, concat.CountNodes());
BDD cond1 = solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(concat))));
Assert.AreEqual <BDD>(cond1, cond);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(concat, "TestShiftLeft2_concat", "c:/tmp/TestShiftLeft2_concat.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestLargeRange2()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"[\u0000-\u7FFF\uA000-\uA00F]");
uint elems = (uint)solver.ComputeDomainSize(cond);
int nodes = cond.CountNodes();
Assert.AreEqual <int>(14, nodes);
var ranges = solver.ToRanges(cond);
Assert.AreEqual <int>(2, ranges.Length);
Assert.AreEqual <uint>(ranges[0].First, 0);
Assert.AreEqual <uint>(ranges[0].Second, 0x7FFF);
Assert.AreEqual <uint>(ranges[1].First, 0xA000);
Assert.AreEqual <uint>(ranges[1].Second, 0xA00F);
Assert.AreEqual <uint>(((uint)1 << 15) + ((uint)1 << 4), elems);
}
public void TestSurrogateRange()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
//high and low surrogate pair elements
BDD cond = solver.MkCharSetFromRegexCharClass(@"\p{Cs}");
cond.ToDot("surr.dot");
int elems = (int)solver.ComputeDomainSize(cond);
int nodes = cond.CountNodes();
Assert.AreEqual <int>(7, nodes); //highly compact BDD representation
var ranges = solver.ToRanges(cond);
Assert.AreEqual <int>(1, ranges.Length);
Assert.AreEqual <uint>(ranges[0].First, 0xd800);
Assert.AreEqual <uint>(ranges[0].Second, 0xdFFF);
//the total number of surrogates (there are 1024 low surrogates and 1024 high surrogates)
Assert.AreEqual <int>(2048, elems);
}
public void TestRanges2()
{
BitWidth enc = BitWidth.BV7;
CharSetSolver solver = new CharSetSolver(enc);
BDD cond = solver.MkCharSetFromRegexCharClass(@"\w");
int nodes = cond.CountNodes();
Pair <uint, uint>[] ranges = solver.ToRanges(cond);
BDD cond2 = solver.MkCharSetFromRanges(ranges);
Assert.AreSame(cond, cond2);
int nodes2 = cond2.CountNodes();
Assert.AreEqual <uint>((uint)'0', ranges[0].First);
Assert.AreEqual <uint>((uint)'9', ranges[0].Second);
Assert.AreEqual <uint>((uint)'A', ranges[1].First);
Assert.AreEqual <uint>((uint)'Z', ranges[1].Second);
Assert.AreEqual <uint>((uint)'_', ranges[2].First);
Assert.AreEqual <uint>((uint)'_', ranges[2].Second);
Assert.AreEqual <uint>((uint)'a', ranges[3].First);
Assert.AreEqual <uint>((uint)'z', ranges[3].Second);
Assert.AreEqual <int>(4, ranges.Length);
}
