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 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_Intersect_SingleElement()
{
var regex = RegExFactory.Range('a');
var intersection = RegExFactory.Intersection(regex);
Assert.AreEqual(regex, intersection);
}
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 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 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_Intersect_EmptyList()
{
var all = RegExFactory.All <char> ();
var empty_intersect = RegExFactory.Intersection(new RegEx <char>[] { });
Assert.AreEqual(all, empty_intersect);
}
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_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 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_Intersection()
{
var regA = RegExFactory.Range('a');
var regB = RegExFactory.Range('b');
var regC = RegExFactory.Range('c');
var inter = RegExFactory.Intersection(regA, regB, regC);
var interChanges = inter.DerivChanges();
var expectedChanges = joinEnumerables(regA.DerivChanges(), regB.DerivChanges(), regC.DerivChanges());
Assert.IsTrue(isUniqueAndSorted(interChanges));
Assert.AreEqual(expectedChanges, interChanges);
}
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_UnionComplex()
{
var ra = RegExFactory.Intersection(RegExFactory.Range <char> ('a'), RegExFactory.Range <char> ('z'));
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(rb + " | (" + ra + ")", r2.ToString());
var r3 = RegExFactory.Union(ra, rb, rc);
Assert.AreEqual(rb + " | " + rc + " | (" + ra + ")", r3.ToString());
}
public void Test_IntersectionSimple()
{
var ra = RegExFactory.Range <char> ('a');
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(ra + " & " + rb, r2.ToString());
var r3 = RegExFactory.Intersection(ra, rb, rc);
Assert.AreEqual(ra + " & " + rb + " & " + rc, r3.ToString());
}
public void Test_Intersect()
{
var regA = RegExFactory.Range('a');
var regB = RegExFactory.Range('b');
var regC = RegExFactory.Range('c');
var regAB = RegExFactory.Intersection(regA, regB);
var regBC = RegExFactory.Intersection(regB, regC);
var regABC = RegExFactory.Intersection(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.Intersection(derivA, derivB));
Assert.AreEqual(derivBC, RegExFactory.Intersection(derivB, derivC));
Assert.AreEqual(derivABC, RegExFactory.Intersection(derivA, derivB, derivC));
}
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);
}
private static RegEx <char> MakeCharRangeRegex(char a, char b)
{
return(RegExFactory.Intersection(RegExFactory.Range(a),
RegExFactory.Complement(RegExFactory.Range((char)(b + 1)))));
}