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