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)));
}