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