protected override ParsingResult SearchKernelInfo(ParsingResult result)
{
ParsingResult parsingResult = base.SearchKernelInfo(result);
int semicolonIndex = parsingResult.SitecoreVersion.IndexOf("; TraceSource", StringComparison.InvariantCultureIgnoreCase);
if (semicolonIndex != -1)
{
parsingResult.SitecoreVersion = parsingResult.SitecoreVersion.Remove(semicolonIndex).TrimEnd('\n', '\r');
}
return parsingResult;
}
private ParsingResult FilterLogs(ParsingResult parsingResultWithoutFiltering, LogReaderSettings settings)
{
ParsingResult parsingResult = new ParsingResult();
foreach (var entry in parsingResultWithoutFiltering.All)
{
bool matchesFilter = false;
ApplyFilter(entry.LogDateTime, settings, entry.ToString(), ref matchesFilter, false);
if (matchesFilter)
parsingResult.AddToGroupAll(entry);
}
return parsingResult;
}
/// <summary>
/// check the iban to make sure that the check digits are correct for the basic bank account number
/// </summary>
/// <param name="iban">the iban to check</param>
internal static bool Validate(ParsingResult iban)
{
if (string.IsNullOrEmpty(iban.BasicAccountNumber))
{
return(true);
}
var rearranged = iban.BasicAccountNumber + iban.CountryCode + iban.CheckDigits;
var converted = string.Join("", rearranged.Select(ToInteger));
var algorithm = new ModChecksumCalculator(97);
return(algorithm.Validate(converted, 1));
}
public void Should_FromResult_ReturnTrueMatchFlagAndResult()
{
// Given
var sessionDefinition = new SessionDefinition("Title", 15);
// When
var result = ParsingResult.FromResult(sessionDefinition);
// Then
result.Should().NotBeNull();
result.IsMatched.Should().Be(true);
result.SessionDefinition.ShouldBeEquivalentTo(sessionDefinition);
}
protected override EnumTableType ParseTableType(ParsingResult parsingResult, GameInfo gameInfo)
{
if (!TryParseTableTypeFromFile(gameInfo.FullFileName, out EnumTableType tableType))
{
tableType = base.ParseTableType(parsingResult, gameInfo);
}
if (gameInfo.TableType > tableType)
{
return(gameInfo.TableType);
}
return(tableType);
}
public ParsingResult[] ParseNK(SqlConnection connection)
{
#region Вставка накопительной карточки
ParsingResult inseredNKResult = ParsingLib.ParseNK.InsertSourceTableToTargetTable("SrcTableNK", "tbl_DocNK_RGD", connection);
#endregion
#region Обновление накопительной карточки
ParsingResult updatedNKResult = ParsingLib.ParseNK.UpdateTargetTable("SrcTableNK", "tbl_DocNK_RGD", connection);
#endregion
ParsingResult[] parsingResultArray = new[] { inseredNKResult, updatedNKResult };
return(parsingResultArray);
}
public override IParsingResult <SingleSampleCommonOptions> Parse(SuccessfulResultCollection parseInput)
{
var bAlleleSites = parseInput.Get(BAlleleSites);
bool isDbSnpVcf = bAlleleSites.MatchedOption.Equals(PopulationBAlleleSites);
var ploidyVcf = parseInput.Get(PloidyVcf);
var sampleName = parseInput.Get(SampleName);
return(ParsingResult <SingleSampleCommonOptions> .SuccessfulResult(
new SingleSampleCommonOptions(
bAlleleSites.Result,
isDbSnpVcf,
ploidyVcf,
sampleName)));
}
public IEnumerable <IResult> Convert(ESDATModel model)
{
var action = Map(model);
var resultLevel = ResultLevel.INFO;
var location = new ODM2ConverterSourceLocation(this.ToString(), "Core.Action");
var message = string.Format("{0}: Core.Action is mappped.", location);
var result = new ParsingResult(resultLevel, message, action, location);
_iResults.Add(result);
PrintToConsole(message);
return(_iResults);
}
public void the_rewritten_uri_is_relative_to_the_app_base()
{
given_resource <Customer>("/customer/{id}");
given_request_uri("http://localhost/vdir/customer/1.xml");
given_context_applicationBase("http://localhost/vdir");
when_parsing();
ParsingResult.ShouldBeTrue();
ProcessedUri.ShouldBe(new Uri("http://localhost/vdir/customer/1"));
when_applying();
Context.PipelineData.ResponseCodec.CodecType.ShouldBe(typeof(XmlCodec));
Context.Response.Entity.ContentType.ShouldBe(MediaType.Xml);
}
public void ParseRequests_Valid(string json, object id, string method, object[] parameters)
{
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Requests);
Assert.Equal(RpcId.FromObject(id), result.Requests[0].Id);
Assert.Equal(method, result.Requests[0].Method);
ParserTests.CompareParameters(parameters, result.Requests[0].Parameters);
Assert.False(result.IsBulkRequest);
}
protected override bool InternalMatch(string title, IntPtr handle, ParsingResult parsingResult)
{
if (string.IsNullOrWhiteSpace(title) || parsingResult == null ||
parsingResult.Source == null || parsingResult.Source.GameDescription == null || string.IsNullOrEmpty(parsingResult.Source.TableName) ||
!TryMatchWindowClass(handle, out string windowClassName))
{
return(false);
}
if (parsingResult.Source.GameDescription.IsTournament)
{
var tableNumber = parsingResult.Source.TableName.Substring(parsingResult.Source.TableName.LastIndexOf(' ') + 1);
var tournamentTitle = string.Format(tournamentPattern, parsingResult.Source.GameDescription.Tournament.TournamentId, tableNumber);
return(title.Contains(tournamentTitle));
}
var tableName = parsingResult.Source.TableName;
// check if there is more than 1 opened table
if (!string.IsNullOrWhiteSpace(parsingResult.FileName))
{
var originalTableName = tableName;
var preparedTableName = tableName.Replace("/", "-");
var tableNameIndex = parsingResult.FileName.IndexOf($"{preparedTableName} #", StringComparison.OrdinalIgnoreCase);
if (tableNameIndex >= 0)
{
// HH20180514 Halley #2 - $0.01-$0.02 - USD No Limit Hold'em.txt
var tableNameEndIndex = parsingResult.FileName.IndexOf(" ", tableNameIndex + tableName.Length + 2);
tableName = parsingResult.FileName
.Substring(tableNameIndex, tableNameEndIndex - tableNameIndex)
.Trim()
.Replace(preparedTableName, originalTableName);
}
}
var result = title.Contains(tableName) && (tableName.Contains("#") || !title.Contains("#"));
if (IsAdvancedLogEnabled)
{
LogProvider.Log.Info($"Check if window '{title}' [{handle}, '{windowClassName}'] matches '{tableName}': {result}. [{SiteString}]");
}
return(result);
}
protected override ParsingResult ProcessCharacterImpl(IParsingContext context, char nextChar)
{
ParsingResult finalResult = ParsingResult.Match;
System.Diagnostics.Debug.Assert(currentCharacterIndex < tokenToMatch.Length * 2);
int currentCompareCharacterIndex = currentCharacterIndex % tokenToMatch.Length;
if (nextChar == tokenToMatch[currentCompareCharacterIndex])
{
currentCharacterIndex++;
if (this.currentCharacterIndex == tokenToMatch.Length * 2)
{
if (this.errorState != null)
{
context.CurrentState = this.errorState;
context.Append(this.tokenToMatch);
}
else
{
finalResult = ParsingResult.Done;
}
this.currentCharacterIndex = 0;
}
}
else
{
if (currentCharacterIndex == 0)
{
finalResult = ParsingResult.Miss;
}
else if (currentCompareCharacterIndex == currentCharacterIndex)
{
context.CurrentState = this.errorState;
context.Append(this.tokenToMatch.Substring(0, this.currentCharacterIndex));
finalResult = ParsingResult.Miss;
}
else
{
context.CurrentState = this.nextState;
context.Append(this.tokenToMatch.Substring(0, currentCompareCharacterIndex));
finalResult = ParsingResult.Miss;
}
this.currentCharacterIndex = 0;
}
return(finalResult);
}
public void ParseRequests_MissingParams_NoException()
{
const string json = "{\"method\": \"datetime\",\"jsonrpc\": \"2.0\", \"id\": \"1\"}";
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Requests);
Assert.Equal("1", result.Requests[0].Id);
Assert.Equal("datetime", result.Requests[0].Method);
Assert.Equal(default(RpcParameters), result.Requests[0].Parameters);
Assert.False(result.IsBulkRequest);
}
public void ParseRequests_MissingId_NoException()
{
const string json = "{\"method\": \"datetime\", \"jsonrpc\": \"2.0\", \"params\": [\"2000-12-15T22:11:03\"]}";
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Requests);
Assert.Equal(default(RpcId), result.Requests[0].Id);
Assert.Equal("datetime", result.Requests[0].Method);
ParserTests.CompareParameters(new object[] { "2000-12-15T22:11:03" }, result.Requests[0].Parameters);
Assert.False(result.IsBulkRequest);
}
public void ParseRequests_MissingMethod_InvalidRequestException()
{
const string json = "{\"jsonrpc\": \"2.0\", \"params\": [\"2000-12-15T22:11:03\"], \"id\": \"1\"}";
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Errors);
Assert.Equal("1", result.Errors[0].Id);
Assert.NotNull(result.Errors[0].Error);
Assert.Equal((int)RpcErrorCode.InvalidRequest, result.Errors[0].Error.Code);
Assert.False(result.IsBulkRequest);
}
public void ParseRequests_EmptyObjectRequest_InvalidRequestException()
{
const string json = "{}";
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Errors);
Assert.Equal(default(RpcId), result.Errors[0].Id);
Assert.NotNull(result.Errors[0].Error);
Assert.Equal((int)RpcErrorCode.InvalidRequest, result.Errors[0].Error.Code);
Assert.False(result.IsBulkRequest);
}
protected override bool InternalMatch(string title, IntPtr handle, ParsingResult parsingResult)
{
if (string.IsNullOrWhiteSpace(title) || parsingResult == null ||
parsingResult.Source == null || parsingResult.Source.GameDescription == null || string.IsNullOrEmpty(parsingResult.Source.TableName))
{
return(false);
}
if (parsingResult.Source.GameDescription.IsTournament)
{
return(title.Contains(parsingResult.Source.GameDescription.Tournament.TournamentId) && title.Contains(parsingResult.Source.TableName));
}
return(title.Contains(parsingResult.Source.TableName));
}
public override IParsingResult <SmallPedigreeOptions> Parse(SuccessfulResultCollection parseInput)
{
var bams = parseInput.Get(Bams);
var ploidyVcf = parseInput.Get(PloidyVcf);
var bAlleleSites = parseInput.Get(BAlleleSites);
var commonCnvsBed = parseInput.Get(CommonCnvsBed);
IParsingResult <SmallPedigreeOptions> failedResult;
if (HasMoreThanOneSameSampleType(bams, out failedResult))
{
return(failedResult);
}
return(ParsingResult <SmallPedigreeOptions> .SuccessfulResult(new SmallPedigreeOptions(bams, commonCnvsBed, bAlleleSites.Result, bAlleleSites.MatchedOption.Equals(PopulationBAlleleSites), ploidyVcf)));
}
private ParsingResult FilterLogs(ParsingResult parsingResultWithoutFiltering, LogReaderSettings settings)
{
ParsingResult parsingResult = new ParsingResult();
foreach (var entry in parsingResultWithoutFiltering.All)
{
bool matchesFilter = false;
ApplyFilter(entry.LogDateTime, settings, entry.ToString(), ref matchesFilter, false);
if (matchesFilter)
{
parsingResult.AddToGroupAll(entry);
}
}
return(parsingResult);
}
public ResultCollection <TResult> Parse(IEnumerable <string> args)
{
Dictionary <IOption, OptionData> optionResults;
OptionSet options = GetOptionSet(out optionResults);
try
{
IEnumerable <string> remainingArgs = options.Parse(args);
return(ParseGeneric(optionResults, remainingArgs));
}
catch (OptionException e)
{
return(new ResultCollection <TResult>(ParsingResult <TResult> .FailedResult(e.Message)));
}
}
public ParsingResult <Course> Parse(string line)
{
var errorBuilder = new StringBuilder();
var result = new ParsingResult <Course>
{
Status = ParsingStatus.Failure
};
var properties = line.Split(',');
// if(properties.Length != 2) throw new ArgumentException($"Invalid line : {line}");
if (properties.Length != 2)
{
errorBuilder.Append("Invalid line");
}
var isIdParsed = int.TryParse(properties[CourseIdColNo], out var id);
// if(!isIdParsed) throw new ArgumentException($"Invalid Id -> line: {line}");
if (!isIdParsed)
{
errorBuilder.Append("Invalid Id");
}
var title = properties[CourseTitleColNo];
// if(string.IsNullOrWhiteSpace(title)) throw new ArgumentException($"Invalid Name -> line : {line}");
if (string.IsNullOrWhiteSpace(title))
{
errorBuilder.Append("Invalid title");
}
if (string.IsNullOrWhiteSpace(errorBuilder.ToString()))
{
result.Status = ParsingStatus.Success;
result.Data = new Course
{
Id = id,
Title = title
};
}
else
{
errorBuilder.Append($". line -> {line}");
result.ErrorReason = errorBuilder.ToString();
}
return(result);
}
public void ParseRequests_SingleBatchRequest_Valid()
{
const string json = "[{\"jsonrpc\": \"2.0\", \"method\": \"one\", \"params\": [\"1\"], \"id\": \"1\"}]";
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Requests);
Assert.Equal("1", result.Requests[0].Id);
Assert.Equal("one", result.Requests[0].Method);
ParserTests.CompareParameters(new object[] { "1" }, result.Requests[0].Parameters);
Assert.True(result.IsBulkRequest);
}
public override ParsingResult <List <T> > Parse(SuccessfulResultCollection input)
{
var values = input.Get(Info);
var results = new List <T>();
foreach (var value in values)
{
var result = _valueOption.Parse(value);
if (!result.Success)
{
return(ParsingResult <List <T> > .FailedResult(result.ErrorMessage));
}
results.Add(result.Result);
}
return(ParsingResult <List <T> > .SuccesfulResult(results));
}
public virtual ParsingResult <T> Parse(string value)
{
if (value == null)
{
return(ParsingResult <T> .SuccessfulResult(_defaultValue));
}
try
{
T parsedValue = (T)Convert.ChangeType(value, GetUnderlyingType(typeof(T)));
return(ParsingResult <T> .SuccessfulResult(parsedValue));
}
catch (Exception)
{
return(ParsingResult <T> .FailedResult($"Error parsing {Info.Name} option: failed to convert {value} to {typeof(T)}"));
}
}
private bool HasMoreThanOne(List <SmallPedigreeSampleOptions> bams, SampleType sampleType, out IParsingResult <SmallPedigreeOptions> failedResult)
{
failedResult = null;
var sameType = bams.Where(bam => bam.SampleType == sampleType);
if (sameType.Count() <= 1)
{
return(false);
}
var bamsSameType = string.Join(",", sameType.Select(bam => $"'{bam.Bam}'"));
failedResult = ParsingResult <SmallPedigreeOptions> .FailedResult($"Pedigree can have at most one sample of type '{sampleType}'. Samples with these bams have the same type: {bamsSameType}");
return(true);
}
public virtual IParsingResult <T> Parse(string value)
{
if (value == null)
{
return(ParsingResult <T> .SuccessfulResult(_defaultValue));
}
try
{
T parsedValue = ConvertInternal(value);
return(ParsingResult <T> .SuccessfulResult(parsedValue));
}
catch (Exception)
{
return(ParsingResult <T> .FailedResult($"Error parsing {Info.Name} option: failed to convert {value} to {typeof(T)}"));
}
}
internal static ParsingResult TryParse(string input, out MetricTimeSpan timeSpan)
{
timeSpan = null;
if (string.IsNullOrWhiteSpace(input))
{
return(ParsingResult.EmptyInputString);
}
var match = ParsingUtilities.Match(input, Patterns);
if (match == null)
{
return(ParsingResult.NotMatched);
}
int hours;
if (!ParsingUtilities.ParseNonnegativeInt(match, HoursGroupName, 0, out hours))
{
return(ParsingResult.Error(HoursIsOutOfRange));
}
int minutes;
if (!ParsingUtilities.ParseNonnegativeInt(match, MinutesGroupName, 0, out minutes))
{
return(ParsingResult.Error(MinutesIsOutOfRange));
}
int seconds;
if (!ParsingUtilities.ParseNonnegativeInt(match, SecondsGroupName, 0, out seconds))
{
return(ParsingResult.Error(SecondsIsOutOfRange));
}
int milliseconds;
if (!ParsingUtilities.ParseNonnegativeInt(match, MillisecondsGroupName, 0, out milliseconds))
{
return(ParsingResult.Error(MillisecondsIsOutOfRange));
}
timeSpan = new MetricTimeSpan(hours, minutes, seconds, milliseconds);
return(ParsingResult.Parsed);
}
private ParsingResult parseNode(Node node, int timeIndex, int intervalDuration)
{
string result = "";
if (node is LeafNode)
{
result = parseLeaf(node, timeIndex, intervalDuration).SmtExpression;
}
else if (node is InternalNode)
{
InternalNode _opNode = node as InternalNode;
ParsingResult pr = parseOperator(_opNode, timeIndex, intervalDuration);
result = pr.SmtExpression;
intervalDuration = pr.IntervalDuration;
}
return(new ParsingResult(result, intervalDuration));
}
private static void Process(Parser parser, string line)
{
List <Token> tokens = parser.Lexer.Tokenize(Plaintext.Line(line)).ToList();
string tokensReport = string.Join(" ", tokens.Select(x => $"{x}"));
Console.WriteLine();
Console.WriteLine($"Tokens: {tokensReport}");
ParsingResult result = parser.Parse(line);
Console.WriteLine();
Console.WriteLine($"Syntax tree:{Environment.NewLine}{result}");
Console.WriteLine();
Console.WriteLine($"{line} = {(result.IsSuccess ? result.Compile(Calculator) : result.ErrorMessage)}");
Console.WriteLine(new string('-', 50));
}
public void ParseOptionInfo_WithMissingInputArgument_ReturnsFailedResult()
{
// arrange
StringOption valueOption = StringOption.Create("value option", "value");
string[] stringInputArgument =
{
"--value"
};
// act
ParsingResult <string> result = valueOption.Parse(stringInputArgument);
// assert
Assert.False(result.Success);
Assert.Contains("required", result.ErrorMessage);
}
public void ParsedHistoryMatchedWindowTitleTest(string handHistoryFile, string title, bool match)
{
var handHistory = ParseHandHistory(handHistoryFile);
var parsingResult = new ParsingResult
{
Source = handHistory,
WasImported = true
};
ConfigureContainer();
var pokerStarsImporter = new PokerStarsImporterStub();
var actualMatch = pokerStarsImporter.Match(title, IntPtr.Zero, parsingResult);
Assert.That(actualMatch, Is.EqualTo(match));
}
protected override bool InternalMatch(string title, IntPtr handle, ParsingResult parsingResult)
{
if (string.IsNullOrWhiteSpace(title) || parsingResult == null || !parsingResult.WasImported ||
parsingResult.Source == null || parsingResult.Source.GameDescription == null)
{
return(false);
}
if (parsingResult.Source.GameDescription.IsTournament)
{
var tournamentTitle = string.Format(tournamentPattern, parsingResult.Source.GameDescription.Tournament.TournamentId, parsingResult.Source.TableName);
return(title.Contains(tournamentTitle));
}
return(title.Contains(parsingResult.Source.TableName));
}
public void AssertExtractedFailDataset()
{
var mockDataSourceLocation = new Mock<IDataSourceLocation>();
var dataSet = new ExtractedDataset<int>(ResultLevel.FATAL);
var baseResult = new BaseResult(ResultLevel.FATAL, "Base result message");
var parsingResult = new ParsingResult(ResultLevel.ERROR, "Parsing result", 123, mockDataSourceLocation.Object);
dataSet.AddParsingResult(baseResult);
dataSet.AddParsingResult(parsingResult);
Assert.False(dataSet.IsExtractedSuccess);
Assert.AreEqual(ResultLevel.FATAL, dataSet.ThresholdLevel);
var entities = dataSet.ExtractedEntities;
Assert.Null(entities);
}
public void AssertExtractedSuccessDataset()
{
var mockDataSourceLocation = new Mock<IDataSourceLocation>();
var dataSet = new ExtractedDataset<int>(ResultLevel.ERROR);
var baseResult = new BaseResult(ResultLevel.INFO, "Base result message");
var parsingResult = new ParsingResult(ResultLevel.INFO, "Parsing result", 123, mockDataSourceLocation.Object);
dataSet.AddParsingResult(baseResult);
dataSet.AddParsingResult(parsingResult);
Assert.True(dataSet.IsExtractedSuccess);
Assert.AreEqual(ResultLevel.ERROR, dataSet.ThresholdLevel);
var entities = dataSet.ExtractedEntities;
Assert.AreEqual(1, entities.Count());
Assert.AreEqual(123, (int)entities.First());
}
public ParsingResult Parse(string expression)
{
InputStream input = new InputStream(expression);
var tokens = grammar.Parse(input);
var filteredTokens = grammar.Filter(tokens);
var mixedTokens = grammar.ConvertToMixed(filteredTokens);
var ast = grammar.CreateAST(mixedTokens);
if (mixedTokens.Count != 1)
throw new ParserException("Wrong expression.");
var optimizedAst = ast.Optimize();
var result = new ParsingResult
{
Tree = optimizedAst,
ParameterNames = Parameters,
ParameterExpressions = grammar.ParameterExpressions.Values.ToArray()
};
return result;
}
protected override ParsingResult ParseSource(ILogSource source, LogReaderSettings settings, ParsingResult result = null)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
TextStorage storage = new TextStorage();
result = result ?? new ParsingResult();
var log = (IEnumerable<string[]>)source;
if (!(source is AzureLogSource))
throw new ApplicationException("Non Azure log source was tried to be parsed by Azure log reader");
foreach (var lines in log)
{
var logEntry = logParser.ParseLine(lines[0], new DateTime(long.Parse(lines[1])), storage);
if (logEntry != null)
{
logEntry = AnalyzeLog(logEntry, storage);
result.AddToGroupAll(logEntry);
}
}
return result;
}
public void InitializeTransferParser()
{
TransferParser = new Parser("t");
TransferParsingResult = TransferParser.Parse(TransferInfo);
}
public void InitializeFunctionParser()
{
FunctionParser = new Parser("t");
FunctionParsingResult = FunctionParser.Parse(FunctionInfo);
}
public ParsingStateTestImpl(ParsingResult result)
{
this.result = result;
}
public void InitializeOperatorParser()
{
OperatorParser = new Parser("t");
OperatorParsingResult = OperatorParser.Parse(OperatorInfo);
}
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);
}
