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()
{
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_Concat_EmptyList()
{
var epsi = RegExFactory.Epsilon <char> ();
var empty_concat = RegExFactory.Concat(new RegEx <char>[] { });
Assert.AreEqual(epsi, empty_concat);
}
public void RegExDfaEpsilonTest()
{
RegEx <char> regEx = RegExFactory.Epsilon <char>();
RegExDfa <char> regExDfa = new RegExDfa <char>(regEx, 1);
CheckNullTransitionTests(regExDfa);
var dfaEpsilon = new RegExDfa <char>(new DFAState <char>(1, new KeyValuePair <char, DFAState <char> >[] { deadTransition }));
Assert.IsTrue(DfaUtils.CompareDfa <RegExDfa <char>, DFAState <char>, char> .Compare(regExDfa, dfaEpsilon));
}
public void Test_Concat_AstarB()
{
var regAStar = RegExFactory.Star(singleton('a'));
var regB = singleton('b');
var regex = RegExFactory.Concat(regAStar, regB);
var deriv = regex.Derivative('b');
Assert.AreEqual(RegExFactory.Epsilon <char> (), deriv);
}
public void Test_Star_Empty()
{
var epsi = RegExFactory.Epsilon <char> ();
var empty = RegExFactory.Empty <char> ();
var star_epsi = RegExFactory.Star(epsi);
var star_empty = RegExFactory.Star(empty);
Assert.IsTrue(star_empty is RegExEpsilon <char>);
Assert.IsTrue(star_epsi is RegExEpsilon <char>);
Assert.AreEqual(0, epsi.CompareTo(star_epsi));
Assert.AreEqual(0, epsi.CompareTo(star_empty));
}
public void Test_Concat_Epsi()
{
var epsi = RegExFactory.Epsilon <char> ();
var regex = RegExFactory.Range('a');
var concat1 = RegExFactory.Concat(epsi, regex);
var concat2 = RegExFactory.Concat(regex, epsi);
Assert.IsTrue(concat1 is RegExRange <char>);
Assert.IsTrue(concat2 is RegExRange <char>);
Assert.AreEqual(0, regex.CompareTo(concat1));
Assert.AreEqual(0, regex.CompareTo(concat2));
}
public void Test_Range()
{
var regex = RegExFactory.Range('b');
var derivChanges = regex.DerivChanges().ToArray();
Assert.AreEqual(1, derivChanges.Length);
Assert.AreEqual('b', derivChanges [0]);
var derivA = regex.Derivative('a');
var derivB = regex.Derivative('b');
var derivC = regex.Derivative('c');
Assert.AreEqual(RegExFactory.Empty <char> (), derivA);
Assert.AreEqual(RegExFactory.Epsilon <char> (), derivB);
Assert.AreEqual(RegExFactory.Epsilon <char> (), derivC);
}
public void Test_Star()
{
var reg1 = RegExFactory.Epsilon <char>();
var reg2 = RegExFactory.Range('a');
var reg3 = RegExFactory.Range('a');
var star1 = RegExFactory.Star(reg1);
var star2 = RegExFactory.Star(reg2);
var star3 = RegExFactory.Star(reg2);
var star4 = RegExFactory.Star(reg3);
Assert.IsTrue(star2.CompareTo(star3) == 0);
Assert.IsTrue(star3.CompareTo(star2) == 0);
Assert.IsTrue(star3.CompareTo(star4) == 0);
Assert.IsTrue(star4.CompareTo(star3) == 0);
Assert.IsTrue(star1.CompareTo(star2) < 0);
Assert.IsTrue(star2.CompareTo(star1) > 0);
}
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);
}