public void Test_IntersectionComplex()
{
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.Intersection(ra);
Assert.AreEqual(ra.ToString(), r1.ToString());
var r2 = RegExFactory.Intersection(ra, rb);
Assert.AreEqual(rb + " & (" + ra + ")", r2.ToString());
var r3 = RegExFactory.Intersection(ra, rb, rc);
Assert.AreEqual(rb + " & " + rc + " & (" + ra + ")", r3.ToString());
}
public void Test_UnionSimple()
{
var ra = RegExFactory.Range <char> ('a');
var rb = RegExFactory.Range <char> ('b');
var rc = RegExFactory.Range <char> ('c');
var r1 = RegExFactory.Union(ra);
Assert.AreEqual(ra.ToString(), r1.ToString());
var r2 = RegExFactory.Union(ra, rb);
Assert.AreEqual(ra + " | " + rb, r2.ToString());
var r3 = RegExFactory.Union(ra, rb, rc);
Assert.AreEqual(ra + " | " + rb + " | " + rc, r3.ToString());
}
public void Test_Sum()
{
var regA = RegExFactory.Range('a');
var regB = RegExFactory.Range('b');
var regC = RegExFactory.Range('c');
var regAB = RegExFactory.Union(regA, regB);
var regBC = RegExFactory.Union(regB, regC);
var regABC = RegExFactory.Union(regA, regB, regC);
var derivA = regA.Derivative('a');
var derivB = regB.Derivative('a');
var derivC = regC.Derivative('a');
var derivAB = regAB.Derivative('a');
var derivBC = regBC.Derivative('a');
var derivABC = regABC.Derivative('a');
Assert.AreEqual(derivAB, RegExFactory.Union(derivA, derivB));
Assert.AreEqual(derivBC, RegExFactory.Union(derivB, derivC));
Assert.AreEqual(derivABC, RegExFactory.Union(derivA, derivB, derivC));
}
public void Test_Concat_XYZ_withEpsiX()
{
var regX = RegExFactory.Range('a');
var X = RegExFactory.Star(regX); // contains epsi
var Y = RegExFactory.Range('b');
var Z = RegExFactory.Range('c');
var derivX = X.Derivative('a');
var derivY = Y.Derivative('a');
var concat = RegExFactory.Concat(X, Y, Z);
var derivConcat = concat.Derivative('a');
Assert.IsTrue(X.HasEpsilon());
Assert.IsFalse(Y.HasEpsilon());
Assert.IsFalse(Z.HasEpsilon());
Assert.AreEqual(
RegExFactory.Union(
RegExFactory.Concat(derivX, Y, Z),
RegExFactory.Concat(derivY, Z)
), derivConcat);
}
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_Order()
{
var epsi = RegExFactory.Epsilon <char>(); // typeId = 0
var range = RegExFactory.Range('a'); // typeId = 1
var range2 = RegExFactory.Range('b'); // typeId = 1
var star = RegExFactory.Star(range); // typeId = 2
var compl = RegExFactory.Complement(range); // typeId = 3
var concat = RegExFactory.Concat(range, star); // typeId = 4
var union = RegExFactory.Union(range, star, range2); // typeId = 5
var inter = RegExFactory.Intersection(range, star, range2); // typeId = 6
// a < b
Assert.IsTrue(epsi.CompareTo(range) < 0);
Assert.IsTrue(range.CompareTo(star) < 0);
Assert.IsTrue(star.CompareTo(compl) < 0);
Assert.IsTrue(compl.CompareTo(concat) < 0);
Assert.IsTrue(concat.CompareTo(union) < 0);
Assert.IsTrue(union.CompareTo(inter) < 0);
// a > b
Assert.IsTrue(range.CompareTo(epsi) > 0);
Assert.IsTrue(star.CompareTo(range) > 0);
Assert.IsTrue(compl.CompareTo(star) > 0);
Assert.IsTrue(concat.CompareTo(compl) > 0);
Assert.IsTrue(union.CompareTo(concat) > 0);
Assert.IsTrue(inter.CompareTo(union) > 0);
// a = b
Assert.IsTrue(epsi.CompareTo(epsi) == 0);
Assert.IsTrue(range.CompareTo(range) == 0);
Assert.IsTrue(star.CompareTo(star) == 0);
Assert.IsTrue(compl.CompareTo(compl) == 0);
Assert.IsTrue(concat.CompareTo(concat) == 0);
Assert.IsTrue(union.CompareTo(union) == 0);
Assert.IsTrue(inter.CompareTo(inter) == 0);
}
public static RegexSymbol MakeUnion(params TokenCategory[] tokens)
{
var regexes = tokens.Select(t => ((RegexSymbol)t)._regexSymbol()).ToArray();
return(new RegexSymbol(() => RegExFactory.Union(regexes)));
}
public static RegexSymbol operator+(RegexSymbol left, RegexSymbol right)
{
return(new RegexSymbol(() => RegExFactory.Union <Symbol>(left, right)));
}
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 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)));
}