public void Test_ComplementSimple()
{
var ra = RegExFactory.Range <char> ('a');
var r1 = RegExFactory.Complement(ra);
Assert.AreEqual("~" + ra, r1.ToString());
}
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 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 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 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)));
}
// 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);
}
// 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_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_Complement()
{
var regA = RegExFactory.Range('a');
var regB = RegExFactory.Range('b');
var derivA = regA.Derivative('a');
var derivB = regB.Derivative('b');
var complA = RegExFactory.Complement(regA);
var complB = RegExFactory.Complement(regB);
var derivComplA = complA.Derivative('a');
var derivComplB = complB.Derivative('b');
Assert.AreEqual(derivComplA, RegExFactory.Complement(derivA));
Assert.AreEqual(derivComplB, RegExFactory.Complement(derivB));
}
public void Test_Complement()
{
var reg1 = RegExFactory.Epsilon <char>();
var reg2 = RegExFactory.Range('a');
var reg3 = RegExFactory.Range('a');
var comp1 = RegExFactory.Complement(reg1);
var comp2 = RegExFactory.Complement(reg2);
var comp3 = RegExFactory.Complement(reg2);
var comp4 = RegExFactory.Complement(reg3);
Assert.IsTrue(comp2.CompareTo(comp3) == 0);
Assert.IsTrue(comp3.CompareTo(comp2) == 0);
Assert.IsTrue(comp3.CompareTo(comp4) == 0);
Assert.IsTrue(comp4.CompareTo(comp3) == 0);
Assert.IsTrue(comp1.CompareTo(comp2) < 0);
Assert.IsTrue(comp2.CompareTo(comp1) > 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_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 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));
}
private static RegEx <char> MakeCharRangeRegex(char a, char b)
{
return(RegExFactory.Intersection(RegExFactory.Range(a),
RegExFactory.Complement(RegExFactory.Range((char)(b + 1)))));
}