public void Test_Intersect_Empty() { var all = RegExFactory.All <char> (); var all_intersect = RegExFactory.Intersection <char> (); Assert.AreEqual(0, all_intersect.CompareTo(all)); }
public void TestNotAllowedCharacters() { var result = RegExParser.Parse("[^ab]"); var regEx = RegExFactory.Intersection(RegExFactory.Range((char)0), RegExFactory.Complement(RegExFactory.Union(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c')))); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void Test_Intersect_SingleElement() { var regex = RegExFactory.Range('a'); var intersection = RegExFactory.Intersection(regex); Assert.AreEqual(regex, intersection); }
public void TestNotEscaped() { var result = RegExParser.Parse("(\\(\\+\\))*"); var regEx = RegExFactory.Star(RegExFactory.Concat(RegExFactory.Range('(', (char)('(' + 1)), RegExFactory.Range('+', (char)('+' + 1)), RegExFactory.Range(')', (char)(')' + 1)))); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void TestComplements() { var result = RegExParser.Parse("^(^a^b)"); var regEx = RegExFactory.Complement(RegExFactory.Concat(RegExFactory.Complement(RegExFactory.Range('a', 'b')), RegExFactory.Complement(RegExFactory.Range('b', 'c')))); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void TestAllAtOnce() { var result = RegExParser.Parse("(^(a|(b|c)*))[^:space:]"); var regEx = RegExFactory.Concat(RegExFactory.Complement(RegExFactory.Union(RegExFactory.Range('a', 'b'), RegExFactory.Star(RegExFactory.Union(RegExFactory.Range('b', 'c'), RegExFactory.Range('c', 'd'))))), RegExFactory.Intersection(RegExFactory.Range((char)0), RegExFactory.Complement(CharactersClasses.space))); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void TestParentheses() { var result = RegExParser.Parse("((a(b))((a)((b))))"); var regEx = RegExFactory.Concat(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'), RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c')); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void TestStars() { var result = RegExParser.Parse("(a******b********)***"); var regEx = RegExFactory.Star(RegExFactory.Concat(RegExFactory.Star(RegExFactory.Range('a', 'b')), RegExFactory.Star(RegExFactory.Range('b', 'c')))); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void TestIntersection() { var result = RegExParser.Parse("a&b&c"); var regEx = RegExFactory.Intersection(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'), RegExFactory.Range('c', 'd')); Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print))); }
public void Test_Intersection() { var reg1 = RegExFactory.Epsilon <char>(); var reg2 = RegExFactory.Range('a'); var reg3 = RegExFactory.Range('a'); var reg4 = RegExFactory.Range('b'); var un1 = RegExFactory.Intersection(reg1); var un2 = RegExFactory.Intersection(reg2); var un3 = RegExFactory.Intersection(reg3); var un4 = RegExFactory.Intersection(reg4); var un5 = RegExFactory.Intersection(reg2, reg3); var un6 = RegExFactory.Intersection(reg3, reg4); var un7 = RegExFactory.Intersection(reg4, reg3); Assert.AreNotEqual(un1, un2); Assert.AreNotEqual(un1, un3); Assert.AreNotEqual(un1, un4); Assert.AreEqual(un2, un3); Assert.AreNotEqual(un2, un4); Assert.AreNotEqual(un3, un4); Assert.AreNotEqual(un5, un6); Assert.AreNotEqual(un5, un7); Assert.AreEqual(un6, un7); }
public void Test_Intersect_EmptyList() { var all = RegExFactory.All <char> (); var empty_intersect = RegExFactory.Intersection(new RegEx <char>[] { }); Assert.AreEqual(all, empty_intersect); }
public void Test_Intersect_XX() { var base_regex = RegExFactory.Range('a'); var intersection = RegExFactory.Intersection(base_regex, base_regex); Assert.IsTrue(intersection is RegExRange <char>); Assert.AreEqual(0, intersection.CompareTo(base_regex)); }
public void Test_Intersect_XYX() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var intersection1 = RegExFactory.Intersection(regex1, regex2, regex1); var intersection2 = RegExFactory.Intersection(regex2, regex1); Assert.AreEqual(intersection1, intersection2); }
public void Test_Intersect_Associativity() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var regex3 = RegExFactory.Range('c'); var int1 = RegExFactory.Intersection(regex1, RegExFactory.Intersection(regex2, regex3)); var int2 = RegExFactory.Intersection(RegExFactory.Intersection(regex1, regex2), regex3); Assert.AreEqual(0, int1.CompareTo(int2)); }
public void TestClasses() { var result1 = RegExParser.Parse("[:digit:]"); var regEx1 = CharactersClasses.digit; Assert.AreEqual(result1, RegExFactory.Intersection(regEx1, RegExFactory.Star(CharactersClasses.print))); var result2 = RegExParser.Parse("[:space:]"); var regEx2 = CharactersClasses.space; Assert.AreEqual(result2, RegExFactory.Intersection(regEx2, RegExFactory.Star(CharactersClasses.print))); }
public void Test_Intersection() { var regA = RegExFactory.Range('a'); var regB = RegExFactory.Range('b'); var regC = RegExFactory.Range('c'); var inter = RegExFactory.Intersection(regA, regB, regC); var interChanges = inter.DerivChanges(); var expectedChanges = joinEnumerables(regA.DerivChanges(), regB.DerivChanges(), regC.DerivChanges()); Assert.IsTrue(isUniqueAndSorted(interChanges)); Assert.AreEqual(expectedChanges, interChanges); }
public void RegExDfaStarTest() { RegEx <char> regEx = RegExFactory.Star <char>(RegExFactory.Intersection <char>(RegExFactory.Range <char>('a'), RegExFactory.Complement <char>(RegExFactory.Range <char>('b')))); RegExDfa <char> regExDfa = new RegExDfa <char>(regEx, 1); CheckNullTransitionTests(regExDfa); DFAState <char> state_1 = new DFAState <char>(); state_1._accepting = 1; state_1._transitions = new KeyValuePair <char, DFAState <char> >[] { deadTransition, new KeyValuePair <char, DFAState <char> >('a', state_1), new KeyValuePair <char, DFAState <char> >('b', deadState) }; var dfaStar = new RegExDfa <char>(state_1); Assert.IsTrue(DfaUtils.CompareDfa <RegExDfa <char>, DFAState <char>, char> .Compare(regExDfa, dfaStar)); }
public void Test_UnionComplex() { var ra = RegExFactory.Intersection(RegExFactory.Range <char> ('a'), RegExFactory.Range <char> ('z')); var rb = RegExFactory.Range <char> ('b'); var rc = RegExFactory.Range <char> ('c'); var r1 = RegExFactory.Union(ra); Assert.AreEqual(ra.ToString(), r1.ToString()); var r2 = RegExFactory.Union(ra, rb); Assert.AreEqual(rb + " | (" + ra + ")", r2.ToString()); var r3 = RegExFactory.Union(ra, rb, rc); Assert.AreEqual(rb + " | " + rc + " | (" + ra + ")", r3.ToString()); }
public void Test_IntersectionSimple() { var ra = RegExFactory.Range <char> ('a'); var rb = RegExFactory.Range <char> ('b'); var rc = RegExFactory.Range <char> ('c'); var r1 = RegExFactory.Intersection(ra); Assert.AreEqual(ra.ToString(), r1.ToString()); var r2 = RegExFactory.Intersection(ra, rb); Assert.AreEqual(ra + " & " + rb, r2.ToString()); var r3 = RegExFactory.Intersection(ra, rb, rc); Assert.AreEqual(ra + " & " + rb + " & " + rc, r3.ToString()); }
public void Test_Intersect() { var regA = RegExFactory.Range('a'); var regB = RegExFactory.Range('b'); var regC = RegExFactory.Range('c'); var regAB = RegExFactory.Intersection(regA, regB); var regBC = RegExFactory.Intersection(regB, regC); var regABC = RegExFactory.Intersection(regA, regB, regC); var derivA = regA.Derivative('a'); var derivB = regB.Derivative('a'); var derivC = regC.Derivative('a'); var derivAB = regAB.Derivative('a'); var derivBC = regBC.Derivative('a'); var derivABC = regABC.Derivative('a'); Assert.AreEqual(derivAB, RegExFactory.Intersection(derivA, derivB)); Assert.AreEqual(derivBC, RegExFactory.Intersection(derivB, derivC)); Assert.AreEqual(derivABC, RegExFactory.Intersection(derivA, derivB, derivC)); }
public void Test_Epsi() { var epsi = RegExFactory.Epsilon <char> (); var range = RegExFactory.Range('a'); var range2 = RegExFactory.Range('b'); Assert.AreEqual(0, epsi.CompareTo(epsi)); // epsi == epsi Assert.AreEqual(0, epsi.CompareTo(RegExFactory.Epsilon <char>())); // epsi == epsi Assert.IsTrue(epsi.CompareTo(RegExFactory.Range('a')) < 0); // epsi < RegExRange(...) Assert.IsTrue(epsi.CompareTo(RegExFactory.Range('a', 'b')) < 0); // epsi < RegexRange(...) Assert.IsTrue(epsi.CompareTo(RegExFactory.Empty <char> ()) < 0); // epsi < empty Assert.IsTrue(epsi.CompareTo(RegExFactory.All <char> ()) < 0); // epsi < all Assert.IsTrue(epsi.CompareTo(RegExFactory.Star(range)) < 0); // epsi < star Assert.IsTrue(epsi.CompareTo(RegExFactory.Complement(range)) < 0); // epsi < complement Assert.IsTrue(epsi.CompareTo(RegExFactory.Concat(range, range)) < 0); // epsi < concat Assert.IsTrue(epsi.CompareTo(RegExFactory.Union(range, range2)) < 0); // epsi < union Assert.IsTrue(epsi.CompareTo(RegExFactory.Intersection(range, range2)) < 0); // epsi < intersection }
public void Test_Order() { var epsi = RegExFactory.Epsilon <char>(); // typeId = 0 var range = RegExFactory.Range('a'); // typeId = 1 var range2 = RegExFactory.Range('b'); // typeId = 1 var star = RegExFactory.Star(range); // typeId = 2 var compl = RegExFactory.Complement(range); // typeId = 3 var concat = RegExFactory.Concat(range, star); // typeId = 4 var union = RegExFactory.Union(range, star, range2); // typeId = 5 var inter = RegExFactory.Intersection(range, star, range2); // typeId = 6 // a < b Assert.IsTrue(epsi.CompareTo(range) < 0); Assert.IsTrue(range.CompareTo(star) < 0); Assert.IsTrue(star.CompareTo(compl) < 0); Assert.IsTrue(compl.CompareTo(concat) < 0); Assert.IsTrue(concat.CompareTo(union) < 0); Assert.IsTrue(union.CompareTo(inter) < 0); // a > b Assert.IsTrue(range.CompareTo(epsi) > 0); Assert.IsTrue(star.CompareTo(range) > 0); Assert.IsTrue(compl.CompareTo(star) > 0); Assert.IsTrue(concat.CompareTo(compl) > 0); Assert.IsTrue(union.CompareTo(concat) > 0); Assert.IsTrue(inter.CompareTo(union) > 0); // a = b Assert.IsTrue(epsi.CompareTo(epsi) == 0); Assert.IsTrue(range.CompareTo(range) == 0); Assert.IsTrue(star.CompareTo(star) == 0); Assert.IsTrue(compl.CompareTo(compl) == 0); Assert.IsTrue(concat.CompareTo(concat) == 0); Assert.IsTrue(union.CompareTo(union) == 0); Assert.IsTrue(inter.CompareTo(inter) == 0); }
private static RegEx <char> MakeCharRangeRegex(char a, char b) { return(RegExFactory.Intersection(RegExFactory.Range(a), RegExFactory.Complement(RegExFactory.Range((char)(b + 1))))); }