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