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 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 Test_Concat_EmptyList() { var epsi = RegExFactory.Epsilon <char> (); var empty_concat = RegExFactory.Concat(new RegEx <char>[] { }); Assert.AreEqual(epsi, empty_concat); }
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_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 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 Test_Concat_SingleElement() { var regex = RegExFactory.Range('a'); var concat = RegExFactory.Concat(regex); Assert.AreEqual(regex, concat); }
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_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)); }
public void Test_Concat_AstarB() { var regAStar = RegExFactory.Star(singleton('a')); var regB = singleton('b'); var regex = RegExFactory.Concat(regAStar, regB); var deriv = regex.Derivative('b'); Assert.AreEqual(RegExFactory.Epsilon <char> (), deriv); }
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_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_AstarB() { var regAStar = RegExFactory.Star(singleton('a')); var regB = singleton('b'); var regex = RegExFactory.Concat(regAStar, regB); var changes = regex.DerivChanges(); var expectedChanges = new char[] { 'a', 'b', 'c' }; Assert.IsTrue(isUniqueAndSorted(changes)); Assert.AreEqual(expectedChanges, changes); }
public void Test_Concat_XYZ_withoutEpsi() { var regA = RegExFactory.Range('a'); var regB = RegExFactory.Range('b'); var regC = RegExFactory.Range('c'); var concat = RegExFactory.Concat(regA, regB, regC); var concatChanges = concat.DerivChanges(); var expectedChanges = regA.DerivChanges(); Assert.IsTrue(isUniqueAndSorted(concatChanges)); Assert.AreEqual(expectedChanges, concatChanges); }
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); }
public void Test_Concat_Epsi() { var epsi = RegExFactory.Epsilon <char> (); var regex = RegExFactory.Range('a'); var concat1 = RegExFactory.Concat(epsi, regex); var concat2 = RegExFactory.Concat(regex, epsi); Assert.IsTrue(concat1 is RegExRange <char>); Assert.IsTrue(concat2 is RegExRange <char>); Assert.AreEqual(0, regex.CompareTo(concat1)); Assert.AreEqual(0, regex.CompareTo(concat2)); }
public void Test_Concat_XYZ() { var regex1 = RegExFactory.Range('a'); var regex2 = RegExFactory.Range('b'); var regex3 = RegExFactory.Range('c'); var concat1 = RegExFactory.Concat(regex1, RegExFactory.Concat(regex2, regex3)); var concat2 = RegExFactory.Concat(RegExFactory.Concat(regex1, regex2), regex3); var concat3 = RegExFactory.Concat(regex1, regex2, regex3); Assert.AreEqual(0, concat1.CompareTo(concat2)); Assert.AreEqual(0, concat2.CompareTo(concat3)); Assert.AreEqual(0, concat3.CompareTo(concat1)); }
public void Test_Star_AstarBstar() { var aStar = RegExFactory.Star(singleton('a')); var bStar = RegExFactory.Star(singleton('b')); var aStarbStar = RegExFactory.Concat(aStar, bStar); var aStarbStarSTAR = RegExFactory.Star(aStarbStar); var expectedA = RegExFactory.Concat(aStarbStar, aStarbStarSTAR); var expectedB = RegExFactory.Concat(bStar, aStarbStarSTAR); Assert.AreEqual(expectedA, aStarbStarSTAR.Derivative('a')); Assert.AreEqual(expectedB, aStarbStarSTAR.Derivative('b')); }
public void Test_Star_AstarBstar() { var aStar = RegExFactory.Star(singleton('a')); var bStar = RegExFactory.Star(singleton('b')); var aSbS = RegExFactory.Concat(aStar, bStar); var aSbS_Star = RegExFactory.Star(aSbS); var changes = aSbS_Star.DerivChanges(); var expectedChanges = new char[] { 'a', 'b', 'c' }; Assert.IsTrue(isUniqueAndSorted(changes)); Assert.AreEqual(expectedChanges, changes); }
public void Test_Concat_AstarBstarCstarDstar_derivD() { var aStar = RegExFactory.Star(singleton('a')); var bStar = RegExFactory.Star(singleton('b')); var cStar = RegExFactory.Star(singleton('c')); var dStar = RegExFactory.Star(singleton('d')); var aSbScSdS = RegExFactory.Concat(aStar, bStar, cStar, dStar); var changes = aSbScSdS.DerivChanges(); var expectedChanges = new char[] { 'a', 'b', 'c', 'd', 'e' }; Assert.IsTrue(isUniqueAndSorted(changes)); Assert.AreEqual(expectedChanges, changes); }
public void Test_Star() { var regA = RegExFactory.Range('a'); var regB = RegExFactory.Range('b'); var derivA = regA.Derivative('a'); var derivB = regB.Derivative('b'); var starA = RegExFactory.Star(regA); var starB = RegExFactory.Star(regB); var derivStarA = starA.Derivative('a'); var derivStarB = starB.Derivative('b'); Assert.AreEqual(derivStarA, RegExFactory.Concat(derivA, starA)); Assert.AreEqual(derivStarB, RegExFactory.Concat(derivB, starB)); }
public void Test_Concat_XY_withEpsi() { var reg = RegExFactory.Range('a'); var X = RegExFactory.Star(reg); // contains epsi var Y = RegExFactory.Range('b'); var derivX = X.Derivative('a'); var derivY = Y.Derivative('a'); var concat = RegExFactory.Concat(X, Y); var derivConcat = concat.Derivative('a'); Assert.IsTrue(X.HasEpsilon()); Assert.AreEqual(RegExFactory.Union(RegExFactory.Concat(derivX, Y), derivY), derivConcat); }
public void Test_Concat_XYZ_withoutEpsi() { var X = RegExFactory.Range('a'); var Y = RegExFactory.Range('b'); var Z = RegExFactory.Range('c'); var derivX = X.Derivative('a'); var concat = RegExFactory.Concat(X, Y, Z); var derivConcat = concat.Derivative('a'); Assert.IsFalse(X.HasEpsilon()); Assert.IsFalse(Y.HasEpsilon()); Assert.IsFalse(Z.HasEpsilon()); Assert.AreEqual(derivConcat, RegExFactory.Concat(derivX, Y, Z)); }
public void Test_Concat_AstarBstarCstarDstar() { var aStar = RegExFactory.Star(singleton('a')); var bStar = RegExFactory.Star(singleton('b')); var cStar = RegExFactory.Star(singleton('c')); var dStar = RegExFactory.Star(singleton('d')); var aSbScSdS = RegExFactory.Concat(aStar, bStar, cStar, dStar); var bScSdS = RegExFactory.Concat(bStar, cStar, dStar); var cSdS = RegExFactory.Concat(cStar, dStar); Assert.AreEqual(aSbScSdS, aSbScSdS.Derivative('a')); Assert.AreEqual(bScSdS, aSbScSdS.Derivative('b')); Assert.AreEqual(cSdS, aSbScSdS.Derivative('c')); Assert.AreEqual(dStar, aSbScSdS.Derivative('d')); Assert.AreEqual(RegExFactory.Empty <char> (), aSbScSdS.Derivative('x')); }
public void Test_ConcatSimple() { var ra = RegExFactory.Range <char> ('a'); var rb = RegExFactory.Range <char> ('b'); var rc = RegExFactory.Range <char> ('c'); var r1 = RegExFactory.Concat(ra); Assert.AreEqual(ra.ToString(), r1.ToString()); var r2 = RegExFactory.Concat(ra, rb); Assert.AreEqual(ra.ToString() + rb, r2.ToString()); var r3 = RegExFactory.Concat(ra, rb, rc); Assert.AreEqual(ra.ToString() + rb + rc, r3.ToString()); }
public void Test_ConcatComplex() { var ra = RegExFactory.Union(RegExFactory.Range <char> ('a'), RegExFactory.Range <char> ('z')); var rb = RegExFactory.Range <char> ('b'); var rc = RegExFactory.Range <char> ('c'); var r1 = RegExFactory.Concat(ra); Assert.AreEqual(ra.ToString(), r1.ToString()); var r2 = RegExFactory.Concat(ra, rb); Assert.AreEqual("(" + ra + ")" + rb, r2.ToString()); var r3 = RegExFactory.Concat(ra, rb, rc); Assert.AreEqual("(" + ra + ")" + rb + rc, r3.ToString()); }
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_Concat_JoinConsecutiveStars() { var starA = RegExFactory.Star(singleton('a')); var starB = RegExFactory.Star(singleton('b')); var regex = RegExFactory.Range('f'); var concatAA = RegExFactory.Concat(starA, starA); Assert.AreEqual(starA, concatAA); var concatAAB = RegExFactory.Concat(starA, starA, starB); Assert.AreEqual(RegExFactory.Concat(starA, starB), concatAAB); var concatABA = RegExFactory.Concat(starA, starB, starA); Assert.AreEqual(RegExFactory.Concat(starA, starB, starA), concatABA); var concatFAAFABBFBBB = RegExFactory.Concat(regex, starA, starA, regex, starA, starB, starB, regex, starB, starB, starB); var expectedFAFABFB = RegExFactory.Concat(regex, starA, regex, starA, starB, regex, starB); Assert.AreEqual(expectedFAFABFB, concatFAAFABBFBBB); }
public void LexerComplexLanguages() { // 0: a+ // 1: a*b // 2: a*b+ var regex0 = RegExFactory.Concat(MakeCharRegex('a'), RegExFactory.Star(MakeCharRegex('a'))); var regex1 = RegExFactory.Concat(RegExFactory.Star(MakeCharRegex('a')), MakeCharRegex('b')); var regex2 = RegExFactory.Concat(RegExFactory.Star(MakeCharRegex('a')), RegExFactory.Concat(MakeCharRegex('b'), RegExFactory.Star(MakeCharRegex('b')))); var lexex = new Nicodem.Lexer.Lexer(regex0, regex1, regex2); Assert.IsTrue(lexex.Process("b").TokenizedTo(T("b", 1, 2))); Assert.IsEmpty(lexex.Process("")); Assert.IsTrue(lexex.Process("a").TokenizedTo(T("a", 0))); Assert.IsTrue(lexex.Process("aaa").TokenizedTo(T("aaa", 0))); Assert.IsTrue(lexex.Process("ab").TokenizedTo(T("ab", 1, 2))); Assert.IsTrue(lexex.Process("abb").TokenizedTo(T("abb", 2))); Assert.IsTrue(lexex.Process("bb").TokenizedTo(T("bb", 2))); Assert.IsTrue(lexex.Process("baabab").TokenizedTo(T("b", 1, 2), T("aab", 1, 2), T("ab", 1, 2))); Assert.IsTrue(lexex.Process("bbab").TokenizedTo(T("bb", 2), T("ab", 1, 2))); Assert.IsTrue(lexex.Process("bbacb").TokenizedTo(T("bb", 2), T("a", 0))); }