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 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 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 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 Test_Star_All() { var all = RegExFactory.All <char> (); var star = RegExFactory.Star(all); Assert.AreEqual(all, star); }
public void Test_ComplementSimple() { var ra = RegExFactory.Range <char> ('a'); var r1 = RegExFactory.Complement(ra); Assert.AreEqual("~" + ra, r1.ToString()); }
public void Test_Concat_EmptyList() { var epsi = RegExFactory.Epsilon <char> (); var empty_concat = RegExFactory.Concat(new RegEx <char>[] { }); Assert.AreEqual(epsi, empty_concat); }
public void Test_Sum_Empty() { var empty = RegExFactory.Empty <char> (); var empty_sum = RegExFactory.Union <char> (); Assert.AreEqual(0, empty_sum.CompareTo(empty)); }
public void Test_Concat_SingleElement() { var regex = RegExFactory.Range('a'); var concat = RegExFactory.Concat(regex); Assert.AreEqual(regex, concat); }
public void Test_Intersect_SingleElement() { var regex = RegExFactory.Range('a'); var intersection = RegExFactory.Intersection(regex); Assert.AreEqual(regex, intersection); }
public void Test_Sum_EmptyList() { var empty = RegExFactory.Empty <char> (); var empty_sum = RegExFactory.Union(new RegEx <char>[] { }); Assert.AreEqual(empty, empty_sum); }
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_Concat_XYZ_withEpsiXY() { var regX = RegExFactory.Range('a'); var regY = RegExFactory.Range('b'); var X = RegExFactory.Star(regX); // contains epsi var Y = RegExFactory.Star(regY); // contains epsi var Z = RegExFactory.Range('c'); var derivX = X.Derivative('a'); var derivY = Y.Derivative('a'); var derivZ = Z.Derivative('a'); var concat = RegExFactory.Concat(X, Y, Z); var derivConcat = concat.Derivative('a'); Assert.IsTrue(X.HasEpsilon()); Assert.IsTrue(Y.HasEpsilon()); Assert.IsFalse(Z.HasEpsilon()); Assert.AreEqual( RegExFactory.Union( RegExFactory.Concat(derivX, Y, Z), RegExFactory.Concat(derivY, Z), derivZ ), derivConcat); }
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_ComplementComplex() { var ra = RegExFactory.Union(RegExFactory.Range <char> ('a'), RegExFactory.Range <char> ('z')); var r1 = RegExFactory.Complement(ra); Assert.AreEqual("~(" + ra + ")", r1.ToString()); }
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 Test_Intersect_EmptyList() { var all = RegExFactory.All <char> (); var empty_intersect = RegExFactory.Intersection(new RegEx <char>[] { }); Assert.AreEqual(all, empty_intersect); }
public void Test_Sum_SingleElement() { var regex = RegExFactory.Range('a'); var union = RegExFactory.Union(regex); Assert.AreEqual(regex, union); }
public void Test_StarSimple() { var ra = RegExFactory.Range <char> ('a'); var r1 = RegExFactory.Star(ra); Assert.AreEqual(ra + "*", r1.ToString()); }
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_StarComplex() { var ra = RegExFactory.Union(RegExFactory.Range <char> ('a'), RegExFactory.Range <char> ('z')); var r1 = RegExFactory.Star(ra); Assert.AreEqual("(" + ra + ")*", r1.ToString()); }
public void Test_Concat() { var reg1 = RegExFactory.Epsilon <char>(); var reg2 = RegExFactory.Range('a'); var reg3 = RegExFactory.Range('a'); var reg4 = RegExFactory.Range('b'); var con1 = RegExFactory.Concat(reg1); var con2 = RegExFactory.Concat(reg2); var con3 = RegExFactory.Concat(reg3); var con4 = RegExFactory.Concat(reg4); var con5 = RegExFactory.Concat(reg2, reg3); var con6 = RegExFactory.Concat(reg3, reg2); var con7 = RegExFactory.Concat(reg3, reg4); Assert.AreNotEqual(con1, con2); Assert.AreNotEqual(con1, con3); Assert.AreNotEqual(con1, con4); Assert.AreEqual(con2, con3); Assert.AreNotEqual(con2, con4); Assert.AreNotEqual(con3, con4); Assert.AreEqual(con5, con6); Assert.AreNotEqual(con5, con7); Assert.AreNotEqual(con6, con7); }
public void Test_Range() { var regex = RegExFactory.Range('a'); var changes = regex.DerivChanges(); Assert.AreEqual(1, changes.Count()); Assert.IsTrue(isUniqueAndSorted(changes)); }
public void Test_Star_Star() { var regex = RegExFactory.Range('c'); var star = RegExFactory.Star(regex); var starstar = RegExFactory.Star(star); Assert.AreEqual(0, star.CompareTo(starstar)); }
// complement(empty) = all public void Test_Complement_Empty() { var all = RegExFactory.All <char> (); var empty = RegExFactory.Empty <char> (); var compl_empty = RegExFactory.Complement(empty); Assert.AreEqual(all, compl_empty); }
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_Sum_XX() { var base_regex = RegExFactory.Range('a'); var sum = RegExFactory.Union(base_regex, base_regex); Assert.IsTrue(sum is RegExRange <char>); Assert.AreEqual(0, sum.CompareTo(base_regex)); }
public void Test_Sum_XYX() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var union1 = RegExFactory.Union(regex1, regex2, regex1); var union2 = RegExFactory.Union(regex2, regex1); Assert.AreEqual(0, union1.CompareTo(union2)); }
public void Test_StarTripleDerivative() { var star = RegExFactory.Star(singleton('a')); var dStar = star.Derivative('a'); var ddStar = dStar.Derivative('a'); var dddStar = ddStar.Derivative('a'); Assert.AreEqual(star, dddStar); }