public void ProcessRegularCharacterTest()
 {
     ParsingContextTestImpl context = new ParsingContextTestImpl();
     ParsingState target = new ParsingState();
     FileReaderTestImpl reader = new FileReaderTestImpl(50);
     System.Text.StringBuilder localText = new System.Text.StringBuilder();
     while (!reader.IsEOF)
     {
         char nextChar = reader.GetNextChar();
         localText.Append(nextChar);
         Assert.AreEqual(target.ProcessCharacter(context, nextChar), ParsingResult.Match);
         Assert.AreEqual<string>(localText.ToString(), context.CurrentText);
     }
 }
 public void NullParsingContextTest()
 {
     ParsingState target = new ParsingState();
     target.ProcessCharacter(null, 'a');
 }
        private static void TestLinkedStates(ParsingResult [] returnResults, int transitionIndex)
        {
            ParsingState target = new ParsingState();
            ParsingResult finalResult = ParsingResult.Match;
            IParsingState expectedState = target;

            for (int i=0; i< returnResults.Length; i++)
            {
                ParsingResult result = returnResults[i];
                ParsingStateTestImpl nextState = new ParsingStateTestImpl(result);
                target.AddNextState(nextState);
                if (i == transitionIndex)
                {
                    finalResult = result;
                    if (finalResult != ParsingResult.Miss)
                    {
                        expectedState = nextState;
                    }
                    else
                    {
                        expectedState = target;
                    }
                }
            }

            ParsingContextTestImpl context = new ParsingContextTestImpl();
            context.CurrentState = target;
            char randomChar = (char)(new Random().Next(char.MinValue, char.MaxValue));
            Assert.AreEqual(target.ProcessCharacter(context, randomChar), finalResult);
            Assert.AreEqual<IParsingState>(expectedState, context.CurrentState);
        }
 public void AddNextStateNullTest()
 {
     ParsingState target = new ParsingState();
     target.SetErrorState(null);
     target.AddNextState(null);
 }
Example #5
0
        public static FieldParser BuildParserWithTwoDelimitersAndQualifier(string delimiter, string rowDelimiter, string qualifier)
        {
            ArgumentVerifier.CheckStringArgument(delimiter, "delimiter");
            ArgumentVerifier.CheckStringArgument(rowDelimiter, "rowDelimiter");
            ArgumentVerifier.CheckStringArgument(qualifier, "qualifier");

            FieldParser parser = new FieldParser();

            parser.initialParsingState = new ParsingState();
            ParsingState fieldState = new ParsingState();
            ParsingState qualifiedFieldState = new ParsingState();

            MatchTokenParsingState firstQualifierState = new MatchTokenParsingState(qualifier);
            parser.rowDelimiterState = new MatchTokenParsingState(rowDelimiter);
            MatchTokenParsingState delimiterState = new MatchTokenParsingState(delimiter);
            MatchEscapedTokenParsingState secondQualifierState = new MatchEscapedTokenParsingState(qualifier);

            parser.initialParsingState.AddNextState(firstQualifierState);
            parser.initialParsingState.AddNextState(fieldState);

            fieldState.AddNextState(parser.rowDelimiterState);
            fieldState.AddNextState(delimiterState);

            qualifiedFieldState.AddNextState(secondQualifierState);

            firstQualifierState.AddNextState(qualifiedFieldState);
            firstQualifierState.SetErrorState(fieldState);

            parser.rowDelimiterState.SetErrorState(fieldState);

            delimiterState.SetErrorState(fieldState);

            secondQualifierState.AddNextState(fieldState);
            secondQualifierState.SetErrorState(qualifiedFieldState);

            return parser;
        }