public override NFAModel ConvertAlternation(AlternationExpression exp)
{
var nfa1 = Convert(exp.Expression1);
var nfa2 = Convert(exp.Expression2);
NFAState head = new NFAState();
NFAState tail = new NFAState();
//build edges
head.AddEdge(nfa1.EntryEdge);
head.AddEdge(nfa2.EntryEdge);
nfa1.TailState.AddEmptyEdgeTo(tail);
nfa2.TailState.AddEmptyEdgeTo(tail);
NFAModel alternationNfa = new NFAModel();
alternationNfa.AddState(head);
alternationNfa.AddStates(nfa1.States);
alternationNfa.AddStates(nfa2.States);
alternationNfa.AddState(tail);
//add an empty entry edge
alternationNfa.EntryEdge = new NFAEdge(head);
alternationNfa.TailState = tail;
return(alternationNfa);
}
public void GetMatchesFindsNoMatchesForEmpty()
{
var expression = new AlternationExpression<char> (m_A);
var match = expression.Match (EmptyList, 0);
Assert.IsFalse (match.Success, "Success");
}
public void GetPossibleMatchLengths_ForEmpty()
{
var expected = new int [] {0};
var expression = new AlternationExpression<char> ();
expression.AssertPossibleMatchLengths (expected);
}
public abstract T ConvertAlternation(AlternationExpression exp);
public void ConstructorSucceedsForNonNullInput()
{
var expression = new AlternationExpression<char> (m_digits[5], m_digits[8]);
}
public void AnyLength_ForEmpty()
{
var expression = new AlternationExpression<char> ();
Assert.IsFalse (expression.AnyLength);
}
public void RegexMatches_StartOrEndForEmpty()
{
IExpression<char> expression =
new AlternationExpression<char>(
new StartExpression<char> (),
new EndExpression<char> ());
string regex = @"^|$";
expression.AssertMatches ("", regex);
}
public void ParamsConstructorThrowArgumentNullExceptionForNullArray()
{
var expression = new AlternationExpression<char> ((IExpression<char>[]) null);
}
public void ParamsConstructorCopiesParamsArraySoParamsArrayModificationDoesNotAffectConstructedExpression()
{
IExpression<char> [] expressions = new [] {m_any, m_any, m_any};
var expression = new AlternationExpression<char> (expressions);
int index = 0;
var list = DigetsList;
// alter array
expressions [0] = m_digits[5];
expressions [1] = m_digits[8];
expressions [2] = m_a;
var matches = expression.GetMatches (list, index);
Assert.AreEqual (3, matches.Count (), "Count");
foreach (var match in matches)
{
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (1, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (1, match.Items.Count, "match.Items.Count");
Assert.AreEqual (list[index], match.Items [0], "match.Items [0]");
}
}
public void GetMatchesOfAor8or5orAnyFindsTwoMatchesForDigitsStartingAt5()
{
AlternationExpression<char> expression = new AlternationExpression<char> (m_a,m_digits[8],m_digits[5],m_any);
int index = 5;
var list = DigetsList;
var matches = expression.GetMatches (list, index);
Assert.AreEqual (2, matches.Count (), "Count");
foreach (var match in matches)
{
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (1, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (1, match.Items.Count, "match.Items.Count");
Assert.AreEqual (list[index], match.Items [0], "match.Items [0]");
}
}
public void GetMatchesOf5orAFindsNoMatchForDigitsStartingAt8()
{
AlternationExpression<char> expression = new AlternationExpression<char> (m_digits[5],m_a);
var matches = expression.GetMatches (DigetsList, 8);
Assert.AreEqual (0, matches.Count (), "Count");
}
public void GetMatchesFindsOneMatchForA()
{
AlternationExpression<char> expression = new AlternationExpression<char> (m_a);
int index = 0;
var list = AList;
var matches = expression.GetMatches (list, index);
Assert.AreEqual (1, matches.Count (), "Count");
var match = matches.First ();
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (1, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (1, match.Items.Count, "match.Items.Count");
Assert.AreEqual (list[index], match.Items [0], "match.Items [0]");
}
public void GetMatchesFindsNoMatchesForEmpty()
{
AlternationExpression<char> expression = new AlternationExpression<char> (m_any);
var matches = expression.GetMatches (EmptyList, 0);
Assert.AreEqual (0, matches.Count (), "Count");
}
public void ConstructorThrowArgumentNullExceptionForSecond()
{
var expression = new AlternationExpression<char> (m_digits[5], (IExpression<char>) null);
}
public void NotAnyLength_For_NotAnyLength()
{
var expression = new AlternationExpression<char> (NotAnyLength);
Assert.IsFalse (expression.AnyLength);
}
public void NotSupportsLookBack_For_LookBackSupported_LookBackNotSupported()
{
var expression = new AlternationExpression<char> (LookBackSupported, LookBackNotSupported);
Assert.IsFalse (expression.SupportsLookBack);
}
public void GetMatchesOfDigits_AnyOr5OrAny()
{
IExpression<char> [] expressions = new [] {m_any, m_digits[5], m_any};
var expression = new AlternationExpression<char> (expressions);
string expected = "5";
int index = 5;
var list = DigetsList;
var matches = expression.GetMatches (list, index).ToList ();
Assert.AreEqual (3, matches.Count (), "Count");
foreach (var match in matches)
{
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (expected.Length, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (expected.Length, match.Items.Count, "match.Items.Count");
string matchedString = new string (match.Items.ToArray ());
Assert.AreEqual (expected, matchedString, "matched string does not match expected value.");
}
}
public void ParamsConstructorSucceedsForNonNullInput()
{
IExpression<char> [] expressions = new [] {m_digits[5], m_digits[8]};
var expression = new AlternationExpression<char> (expressions);
}
public void GetMatchesOfEmptyFindsOneZeroLengthMatchForDigitsStartingAt8()
{
AlternationExpression<char> expression = new AlternationExpression<char> ();
int index = 8;
var list = DigetsList;
int length = 0;
var matches = expression.GetMatches (list, index);
Assert.AreEqual (1, matches.Count (), "Count");
var match = matches.First ();
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (length, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (length, match.Items.Count, "match.Items.Count");
}
public void RegexMatches_AAorAB()
{
IExpression<char> expression =
new AlternationExpression<char>(
new ListExpression<char> (
new CharClass ('A'),
new CharClass ('A')),
new ListExpression<char> (
new CharClass ('A'),
new CharClass ('B'))
);
string regex = @"(AA)|(AB)";
expression.AssertMatches ("AAABAB", regex);
expression.AssertMatches ("00000000000000AAABAB000000", regex);
}
public void GetMatchesOfNullThrowsArgumentNullException()
{
AlternationExpression<char> expression = new AlternationExpression<char> (m_digits[5],m_a);
var matches = expression.GetMatches (null, 8);
}
public void SupportsLookBack_For_LookBackSupported()
{
var expression = new AlternationExpression<char> (LookBackSupported);
Assert.IsTrue (expression.SupportsLookBack);
}
public void GetMatchesOf_AnyOr56_ForDigitsStartingAt5()
{
int index = 5;
AlternationExpression<char> expression =
new AlternationExpression<char>(
m_any,
new ListExpression<char>(m_digits[5],m_digits[6]));
var list = DigetsList;
var matches = expression.GetMatches (list, index).ToList ();
string[] expectedMatches = new [] {"5","56"};
Assert.AreEqual (expectedMatches.Length, matches.Count (), "Count");
int matchesIndex = 0;
foreach (var match in matches)
{
string expected = expectedMatches [matchesIndex];
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (expected.Length, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (expected.Length, match.Items.Count, "match.Items.Count");
string matchedString = new string (match.Items.ToArray ());
Assert.AreEqual (expected, matchedString, "matched string does not match expected value.");
matchesIndex++;
}
}
public void AnyLength_For_AnyLength_NotAnyLength()
{
var expression = new AlternationExpression<char> (AnyLength, NotAnyLength);
Assert.IsTrue (expression.AnyLength);
}
public void GetPossibleMatchLengths_For0_2_3to5()
{
var expected = new int [] {0, 2, 3,4,5};
var expression = new AlternationExpression<char> (MatchLength0,MatchLength2,MatchLengths3to5);
expression.AssertPossibleMatchLengths (expected);
}
public void ConstructorThrowArgumentNullExceptionForFirst()
{
var expression = new AlternationExpression<char> ((IExpression<char>) null, m_digits[5]);
}
public void GetPossibleMatchLengths_For1_2()
{
var expected = new int [] {1,2};
var expression = new AlternationExpression<char> (MatchLength1,MatchLength2);
expression.AssertPossibleMatchLengths (expected);
}
