public void Test_Sum_EmptyList()
{
var empty = RegExFactory.Empty <char> ();
var empty_sum = RegExFactory.Union(new RegEx <char>[] { });
Assert.AreEqual(empty, empty_sum);
}
public void Test_Sum_Empty()
{
var empty = RegExFactory.Empty <char> ();
var empty_sum = RegExFactory.Union <char> ();
Assert.AreEqual(0, empty_sum.CompareTo(empty));
}
// 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);
}
public void RegExDfaEmptyTest()
{
RegEx <char> regEx = RegExFactory.Empty <char>();
RegExDfa <char> regExDfa = new RegExDfa <char>(regEx, 1);
CheckNullTransitionTests(regExDfa);
var dfaEmpty = new RegExDfa <char>(new DFAState <char>(0, new KeyValuePair <char, DFAState <char> >[] { deadTransition }));
Assert.IsTrue(DfaUtils.CompareDfa <RegExDfa <char>, DFAState <char>, char> .Compare(regExDfa, dfaEmpty));
}
public void Test_Empty()
{
var empty = RegExFactory.Empty <char>();
Assert.IsTrue(empty is RegExUnion <char>);
var emp = empty as RegExUnion <char>;
Assert.AreEqual(0, emp.Regexes.Length);
}
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_Empty()
{
var empty = RegExFactory.Empty <char> ();
var derivChanges = empty.DerivChanges().ToList();
Assert.AreEqual(0, derivChanges.Count);
for (var c = 'a'; c <= 'z'; c++)
{
var deriv = empty.Derivative(c);
Assert.AreEqual(empty, 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 LexerEmpty()
{
foreach (var arr in new[] { new RegEx <char> [0], new[] { RegExFactory.Empty <char>() } })
{
var lexer = new Nicodem.Lexer.Lexer(arr);
Assert.IsEmpty(lexer.Process(""));
Assert.IsEmpty(lexer.Process(" "));
Assert.IsEmpty(lexer.Process("a"));
Assert.IsEmpty(lexer.Process("asdf"));
Assert.IsEmpty(lexer.Process(" _\n"));
Assert.IsEmpty(lexer.Process("*^& GY?'\t\n\t\tlikjd"));
Assert.IsEmpty(lexer.Process("\\"));
Assert.IsEmpty(lexer.Process("\\n"));
}
}
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_Concat_AstarBstarCstarDstar()
{
var aStar = RegExFactory.Star(singleton('a'));
var bStar = RegExFactory.Star(singleton('b'));
var cStar = RegExFactory.Star(singleton('c'));
var dStar = RegExFactory.Star(singleton('d'));
var aSbScSdS = RegExFactory.Concat(aStar, bStar, cStar, dStar);
var bScSdS = RegExFactory.Concat(bStar, cStar, dStar);
var cSdS = RegExFactory.Concat(cStar, dStar);
Assert.AreEqual(aSbScSdS, aSbScSdS.Derivative('a'));
Assert.AreEqual(bScSdS, aSbScSdS.Derivative('b'));
Assert.AreEqual(cSdS, aSbScSdS.Derivative('c'));
Assert.AreEqual(dStar, aSbScSdS.Derivative('d'));
Assert.AreEqual(RegExFactory.Empty <char> (), aSbScSdS.Derivative('x'));
}
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
}