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 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 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 Test_ComplementSimple() { var ra = RegExFactory.Range <char> ('a'); var r1 = RegExFactory.Complement(ra); Assert.AreEqual("~" + ra, r1.ToString()); }
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_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_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 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_SingleElement() { var regex = RegExFactory.Range('a'); var concat = RegExFactory.Concat(regex); Assert.AreEqual(regex, concat); }
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_SingleElement() { var regex = RegExFactory.Range('a'); var intersection = RegExFactory.Intersection(regex); Assert.AreEqual(regex, intersection); }
public void Test_StarSimple() { var ra = RegExFactory.Range <char> ('a'); 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_Sum_SingleElement() { var regex = RegExFactory.Range('a'); var union = RegExFactory.Union(regex); Assert.AreEqual(regex, union); }
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)); }
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_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_Range() { var regex = RegExFactory.Range('a'); var changes = regex.DerivChanges(); Assert.AreEqual(1, changes.Count()); Assert.IsTrue(isUniqueAndSorted(changes)); }
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_Concat_XY_YX() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var concat1 = RegExFactory.Concat(regex1, regex2); var concat2 = RegExFactory.Concat(regex2, regex1); Assert.IsFalse(0 == concat1.CompareTo(concat2)); }
// complement(complement(X)) = X public void Test_Complement_Double() { var regex = RegExFactory.Range('a'); var compl = RegExFactory.Complement(regex); var compl2 = RegExFactory.Complement(compl); Assert.IsTrue(compl2 is RegExRange <char>); Assert.AreEqual(0, regex.CompareTo(compl2)); }
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 Test_Concat_Empty() { var regex = RegExFactory.Range('a'); var empty = RegExFactory.Empty <char> (); var concat1 = RegExFactory.Concat(empty, regex); var concat2 = RegExFactory.Concat(regex, empty); Assert.AreEqual(0, empty.CompareTo(concat1)); Assert.AreEqual(0, empty.CompareTo(concat2)); }
public void Test_Sum_Associativity() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var regex3 = RegExFactory.Range('c'); var union1 = RegExFactory.Union(regex1, RegExFactory.Union(regex2, regex3)); var union2 = RegExFactory.Union(RegExFactory.Union(regex1, regex2), regex3); Assert.AreEqual(0, union1.CompareTo(union2)); }
public void Test_Complement() { var regex = RegExFactory.Range('a'); var compl = RegExFactory.Complement(regex); var regexChanges = regex.DerivChanges(); var complChanges = compl.DerivChanges(); Assert.AreEqual(regexChanges, complChanges); Assert.IsTrue(isUniqueAndSorted(complChanges)); }
public void Test_Star() { var regex = RegExFactory.Range('a'); var star = RegExFactory.Star(regex); var regexChanges = regex.DerivChanges(); var starChanges = star.DerivChanges(); Assert.AreEqual(regexChanges, starChanges); Assert.IsTrue(isUniqueAndSorted(starChanges)); }
public void Test_Concat_XY_withoutEpsi() { var X = RegExFactory.Range('a'); // does not contain epsi var Y = RegExFactory.Range('b'); var derivX = X.Derivative('a'); var concat = RegExFactory.Concat(X, Y); var derivConcat = concat.Derivative('a'); Assert.IsFalse(X.HasEpsilon()); Assert.AreEqual(derivConcat, RegExFactory.Concat(derivX, Y)); }
public void Test_Concat_XYZ_withEpsiXYZ() { var regA = RegExFactory.Star(RegExFactory.Range('a')); var regB = RegExFactory.Star(RegExFactory.Range('b')); var regC = RegExFactory.Star(RegExFactory.Range('c')); var concat = RegExFactory.Concat(regA, regB, regC); var concatChanges = concat.DerivChanges(); var expectedChanges = joinEnumerables(regA.DerivChanges(), regB.DerivChanges(), regC.DerivChanges()); Assert.IsTrue(isUniqueAndSorted(concatChanges)); Assert.AreEqual(expectedChanges, concatChanges); }