public void Test_Star_All() { var all = RegExFactory.All <char> (); var star = RegExFactory.Star(all); Assert.AreEqual(all, star); }
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 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_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_StarSimple() { var ra = RegExFactory.Range <char> ('a'); var r1 = RegExFactory.Star(ra); Assert.AreEqual(ra + "*", r1.ToString()); }
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 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_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_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); }
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_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 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_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_Star_Empty() { var epsi = RegExFactory.Epsilon <char> (); var empty = RegExFactory.Empty <char> (); var star_epsi = RegExFactory.Star(epsi); var star_empty = RegExFactory.Star(empty); Assert.IsTrue(star_empty is RegExEpsilon <char>); Assert.IsTrue(star_epsi is RegExEpsilon <char>); Assert.AreEqual(0, epsi.CompareTo(star_epsi)); Assert.AreEqual(0, epsi.CompareTo(star_empty)); }
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_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_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 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_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_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_Star() { var reg1 = RegExFactory.Epsilon <char>(); var reg2 = RegExFactory.Range('a'); var reg3 = RegExFactory.Range('a'); var star1 = RegExFactory.Star(reg1); var star2 = RegExFactory.Star(reg2); var star3 = RegExFactory.Star(reg2); var star4 = RegExFactory.Star(reg3); Assert.IsTrue(star2.CompareTo(star3) == 0); Assert.IsTrue(star3.CompareTo(star2) == 0); Assert.IsTrue(star3.CompareTo(star4) == 0); Assert.IsTrue(star4.CompareTo(star3) == 0); Assert.IsTrue(star1.CompareTo(star2) < 0); Assert.IsTrue(star2.CompareTo(star1) > 0); }
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))); }