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); }