C# CharSetSolver.ToRanges方法代码示例

        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 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);
 }

 public void TestRanges2b()
 {
     BitWidth enc = BitWidth.BV16;
     CharSetSolver solver = new CharSetSolver(enc);
     BDD cond = solver.MkCharSetFromRegexCharClass(@"\w");
     var ranges1 = solver.ToRanges(cond);
     var cond1 = solver.MkCharSetFromRanges(ranges1);
     Pair<uint, uint>[] ranges = solver.ToRanges(cond1);
     var cond2 = solver.MkCharSetFromRanges(ranges);
     Assert.AreSame(cond1, cond2);
     Assert.AreSame(cond, cond1);
     //cond.ToDot("cond.dot");
     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>(426, ranges.Length);
 }

 public void TestRanges()
 {
     CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
     BDD cond = solver.MkCharSetFromRange('A', 'Y');
     Pair<uint, uint>[] ranges = solver.ToRanges(cond);
     Assert.AreEqual<int>(1, ranges.Length);
     Assert.AreEqual<uint>((uint)'A', ranges[0].First);
     Assert.AreEqual<uint>((uint)'Y', ranges[0].Second);
 }

 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 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 GenerateMembersTest2()
        {
            CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
            var ranges = new char[][] {
                new char[] { 'a', 'c' },
                new char[] {'\u5555', '\u55A5'},
                new char[] { 'e', 'h' },
                new char[] {'\u55A0', '\u55AA'},
            };
            BDD s = solver.MkRangesConstraint(false, ranges);
            s.ToDot("bug.dot");

            var r = solver.ToRanges(s);
            var s2 = solver.MkCharSetFromRanges(r);

            var members = new List<char>(solver.GenerateAllCharacters(s2, false));
            var smallest = (char)solver.GetMin(s2);

            Assert.AreEqual<int>(93, members.Count, "wrong number of members in the range [a-ce-h\\u5555-\\u55AA]");
            Assert.AreEqual<char>('a', members[0], "the smallest character in the range must be 'a'");
            Assert.AreEqual<char>('\u55AA', members[members.Count - 1], "the largest character in the range must be '\\u55AA'");

            var membersInReverse = new List<char>(solver.GenerateAllCharacters(s, true));

            Assert.AreEqual<int>(93, membersInReverse.Count, "wrong number of members in the range [a-ce-h\\u5555-\\u55AA]");
            Assert.AreEqual<char>('\u55AA', membersInReverse[0], "the first character in the reverse enumeration must be '\\u55AA'");
            Assert.AreEqual<char>('a', membersInReverse[membersInReverse.Count-1], "the last character in the reverse enumeration must be 'a'");
        }