public void Compile_WhenTheGrammarContainsAnAndExpression_TheTypeOfTheAndExpressionReflectsTheInnerExpression(string type) { var grammar = new PegParser().Parse("a = x:&(<" + type + "> 'OK' { null })"); var compiled = PegCompiler.Compile(grammar); Assert.That(compiled.ExpressionTypes[grammar.Rules.Single().Expression].ToString(), Is.EqualTo(type)); }
public void Compile_WhenTheGrammarHasAnErrorExpressionInTheMiddleOfASequenceWrappedInParentheses_ThrowsException() { var grammar = new PegParser().Parse("a = 'OK' (#error{ \"OK\" }) 'OK'"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(() => parser.Parse("OK"), Throws.InstanceOf <FormatException>().With.Message.EqualTo("OK")); }
public void Compile_WhenAZeroLengthProductionIsRepeatedWithADelimiter_YieldsNoErrors() { var grammar = new PegParser().Parse("start = ''<0,,'OK'>"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty); }
public void Compile_ForAllFoundTutorials_Succeeds(Tutorial tutorial) { var grammar = new PegParser().Parse(tutorial.GrammarText); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void Compile_WhenARuleContainsAStateExpressionAsPartOfASequenceThatEndsWithACodeExpression_IncludesTheContentOfTheCodeExpression() { var grammar = new PegParser().Parse("foo = #{OK;} a:'OK' {TEST};"); var result = PegCompiler.Compile(grammar); Assert.That(result.Code, Contains.Substring("TEST")); }
public void Compile_WhenARuleContainsAStateExpressionAsPartOfASequence_IncludesTheContentOfThatStateExpression() { var grammar = new PegParser().Parse("foo = #STATE{TEST;} 'OK';"); var result = PegCompiler.Compile(grammar); Assert.That(result.Code, Contains.Substring("TEST")); }
public void Parse_WhenZeroWidthRepetitionIsBlockedByAssertions_YieldsNoErrors(string grammarText) { var grammar = new PegParser().Parse(grammarText); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty); }
public void Compile_WhenGivenAGrammarWithUnusedRules_YieldsNoErrors() { var grammar = new PegParser().Parse("i = 'OK'; unused = '';"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty); }
public void Compile_WithRulesOnlyUsedByExportOrPublic_YieldsNone() { var grammar = new PegParser().Parse("start = 'OK'; B -export = 'OK'; C -public = 'OK';"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void Compile_WithSingleSimpleRule_Succeeds() { var grammar = new PegParser().Parse("start = 'OK'"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void LetterA() { TestGrammar1 grammar = TestGrammar1.Create(); PegParser parser = new PegParser(grammar, grammar.GetNonterminal(o => o.LetterA())); Assert.IsNotNull(parser.ParseString("a")); Assert.IsNull(parser.ParseString("b")); }
public void Compile_WhenErrorExpressionIsRepeated_YieldsNoErrors() { var grammar = new PegParser().Parse("a = (#error{ \"\" })*"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty); }
public void Compile_WhenGivenAGrammarWithARuleWithAnImmediateTypedExpression_DoesNotThrowAnExceptionOrReturnErrors() { var grammar = new PegParser().Parse("top = item:(<string> 'a' 'b') {item}"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void Compile_WithRulesOnlyUsedByExportOrPublic_YieldsNone(string flag) { var grammar = new PegParser().Parse($"other = 'OK'; A {flag} = other;"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void Compile_WhenTheGrammarRepeatsAZeroWidthExpressionWithSameMinAndMax_YieldsNone() { var grammar = new PegParser().Parse("a = ''<5>"); var result = PegCompiler.Compile(grammar); Assert.That(result.Errors, Is.Empty); }
public void RepeatResets() { var grammar = TestGrammar.Create(); var parser = new PegParser <TestData>(grammar, grammar.Root()); var input = "AAABBBBB"; var result = parser.Parse(input); Assert.AreEqual(input, result.Items); }
public void Parse_WithPegGrammar_Works() { var subject = File.ReadAllText("PegParser.peg"); var parser = new PegParser(); var result = parser.Parse(subject); Assert.That(result, Is.Not.Null); }
public void Compile_WhenGivenAGrammarWithAnInvalidAccessibilitySetting_YieldsError(string settingName, string value) { var grammar = new PegParser().Parse("@" + settingName + " {" + value + "}; a = 'OK';"); var result = PegCompiler.Compile(grammar); var error = result.Errors.Single(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0012")); }
public void Parse_WithNoRules_YieldsEmptyGrammar() { var subject = string.Empty; var parser = new PegParser(); var grammar = parser.Parse(subject); Assert.That(grammar.Rules, Is.Empty); }
public void Parse_WithClassExpression_YieldsClassExpressionWithCorrectCaseSensitivity(string subject, bool?ignoreCase) { var parser = new PegParser(); var grammar = parser.Parse(subject); var charClass = (ClassExpression)grammar.Rules.Single().Expression; Assert.That(charClass.IgnoreCase, Is.EqualTo(ignoreCase)); }
public void Compile_WhenEmptyParensAreIncluded_CompilesCorrectly() { var grammar = new PegParser().Parse("a = () b; b = 'OK';"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Parse_WithClassExpression_YieldsClassExpressionWithCorrectCaseSensitivity(string subject, bool? ignoreCase) { var parser = new PegParser(); var grammar = parser.Parse(subject); var charClass = (ClassExpression)grammar.Rules.Single().Expression; Assert.That(charClass.IgnoreCase, Is.EqualTo(ignoreCase)); }
public void Parse_WhenTheGrammarIsEntirelyEmpty_ReturnsAnEmptySequence(string subject) { var parser = new PegParser(); var grammar = parser.Parse(subject); var result = (SequenceExpression)grammar.Rules.Single().Expression; Assert.That(result.Sequence, Is.Empty); }
public void Compile_WhenEmptyParensAreIncluded_CompilesCorrectly() { var grammar = new PegParser().Parse("a = () b; b = 'OK';"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void CaptureInitializedProperly() { var grammar = TestGrammar.Create(); var parser = new PegParser <TestData>(grammar, grammar.Root()); var input = "AAABBBBB"; var result = parser.Parse(input); Assert.AreEqual(input, result.Items); }
public void Compile_WhenRuleNameIsAReservedWord_CompilesCorrectly(string grammarText) { var grammar = new PegParser().Parse(grammarText); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Compile_WhenAZeroLengthProductionIsRepeated_YieldsError(string grammarText) { var grammar = new PegParser().Parse(grammarText); var result = PegCompiler.Compile(grammar); var error = result.Errors.Where(e => !e.IsWarning).Single(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0021")); }
public void Parse_WithSingleEmptyRule_YieldsRuleWithMatchingName() { var subject = "testName = "; var parser = new PegParser(); var grammar = parser.Parse(subject); Assert.That(grammar.Rules.Single().Identifier.Name, Is.EqualTo("testName")); }
public void Parse_WithLiteralExpression_YieldsLiteralExpressionWithCorrectCaseSensitivity(string subject, bool ignoreCase) { var parser = new PegParser(); var grammar = parser.Parse(subject); var literal = (LiteralExpression)grammar.Rules.Single().Expression; Assert.That(literal.IgnoreCase, Is.EqualTo(ignoreCase)); }
public void Compile_WhenTheGrammarContainsAnAndCodeExpression_ExecutesExpression() { var grammar = new PegParser().Parse("a = &{true} 'OK'"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Compile_WithCaseSensitivityCombinations_ProducesCorrectParser(string subject, string match, string unmatch) { var grammar = new PegParser().Parse(subject); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse(match), Is.EqualTo(match)); Assert.That(() => parser.Parse(unmatch), Throws.Exception); }
public void Compile_Performance_PegGrammar() { var pegGrammar = new PegParser().Parse(File.ReadAllText("PegParser.peg")); Evaluate(() => { PegCompiler.Compile(pegGrammar); }); }
public void Compile_WithStartRule_ProducesCorrectParser() { var grammar = new PegParser().Parse("@start b; a = #error{ \"wrong start rule\" }; b = 'OK';"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Compile_WhenTheGrammarContainsAParseExpression_ExecutesTheParseExpression() { var grammar = new PegParser().Parse("a = #parse{ this.ReturnHelper<string>(state, ref state, _ => \"OK\") };"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse(string.Empty), Is.EqualTo("OK")); }
public void Compile_WhenTheGrammarContainsAnAndExpression_ExecutesExpression() { var grammar = new PegParser().Parse("a = &other 'OK'; other <int> = 'OK' { 0 }"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Compile_WhenTheGrammarContainsANotCodeExpression_ExecutesExpression() { var grammar = new PegParser().Parse("a = !{false} 'OK'"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse("OK"), Is.EqualTo("OK")); }
public void Compile_WithSimpleLeftRecursion_ProducesCorrectParser() { var grammar = new PegParser().Parse("a <int> -memoize = a:a '+' b:b { a + b } / b; b <int> = c:[0-9] { int.Parse(c) };"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <int>(compiled); Assert.That(parser.Parse("1+3"), Is.EqualTo(4)); }
public void Parse_WhenARepetitionDelimiterFollowsTheRepeatedRule_DoesNotConsumeTheDelimiter() { var grammar = new PegParser().Parse("start = ' ' 'hoge'<1,,' '> ' ';"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile <string>(compiled); Assert.That(parser.Parse(" hoge "), Is.EqualTo(" hoge ")); }
public void Compile_ImpossibleQuantifier_YieldsWarning(int min, int max) { var grammar = new PegParser().Parse("a = 'OK'<" + min + "," + max + ">;"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0015")); Assert.That(error.IsWarning, Is.True); }
public void Parse_WithLiteralExpression_YieldsLiteralExpressionWithCorrectString() { var subject = "a = 'testString'"; var parser = new PegParser(); var grammar = parser.Parse(subject); var literal = (LiteralExpression)grammar.Rules.Single().Expression; Assert.That(literal.Value, Is.EqualTo("testString")); }
public void Compile_WhenPublicRuleNameIsLowercase_YieldsWarning() { var grammar = new PegParser().Parse("a -public = 'OK'"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0025")); Assert.That(error.IsWarning, Is.True); }
public void Compile_WhenACSharpExpressionContainsError_YieldsError() { var grammar = new PegParser().Parse("a = {{ return \"OK\" }}"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("CS1002")); Assert.That(error.IsWarning, Is.False); }
public void Compile_WhenACSharpExpressionContainsWarnings_YieldsWarning() { var grammar = new PegParser().Parse("a = {{\n#warning OK\nreturn \"OK\";\n}}"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("CS1030")); Assert.That(error.IsWarning, Is.True); }
public void Parse_ForAllFoundTutorials_Succeeds(Tutorial tutorial) { var grammar = new PegParser().Parse(tutorial.GrammarText); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<object>(compiled.Code); var result = parser.Parse(tutorial.TestText); Assert.That(result, Is.Not.Null); }
public void Parse_For05Calculator_ReturnsCorrectValueForMathematicalExpressions(string expression, double value) { var tutorial = Tutorial.FindAll().Single(t => t.Name == "05 - Calculator"); var grammar = new PegParser().Parse(tutorial.GrammarText); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<object>(compiled); var result = parser.Parse(expression); Assert.That(result, Is.EqualTo(value).Within(0.1).Percent); }
public void RegressionTest() { var grammar = new PegParser().Parse(File.ReadAllText(@"Tracing\tracing-test.peg")); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<string>(compiled); parser.Tracer = NullTracer.Instance; parser.Parse(File.ReadAllText(@"Tracing\tracing-test.txt")); Assert.Pass(); }
public void Compile_WhenTheGrammarHasLexicalRuleConsistingOfANameExpression_ProducesAParserThatReturnsTheLexicalElements() { var grammar = new PegParser().Parse("a -lexical = b; b = 'OK';"); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<string>(compiled.Code); IList<LexicalElement> lexicalElements; var result = parser.Parse("OK", null, out lexicalElements); var actual = lexicalElements.Select(e => e.Name + "@" + e.StartCursor.Location + ":" + e.EndCursor.Location).ToArray(); Assert.That(actual, Is.EqualTo(new[] { "a@0:2" })); }
public void EndToEndTest() { var grammar = new PegParser().Parse(File.ReadAllText(@"Tracing\tracing-test.peg")); var compiled = PegCompiler.Compile(grammar); var parser = CodeCompiler.Compile<string>(compiled); parser.Tracer = DiagnosticsTracer.Instance; var output = TraceUtility.Trace(() => { parser.Parse(File.ReadAllText(@"Tracing\tracing-test.txt")); }); var stateKey = Regex.Match(output, @"state key (\d+)").Groups[1].Value; Assert.That(output, Is.EqualTo(StringUtilities.JoinLines( $"Begin 'start' at (1,1) with state key {stateKey}", $" Begin 'basicRule' at (1,1) with state key {stateKey}", $" End 'basicRule' with success at (1,3) with state key {stateKey}", $" Begin 'leftRecursiveRule' at (1,3) with state key {stateKey}", $" Cache miss.", $" Seeding left-recursion with an unsuccessful match.", $" Begin 'leftRecursiveRule' at (1,3) with state key {stateKey}", $" Cache hit.", $" End 'leftRecursiveRule' with failure at (1,3) with state key {stateKey}", $" Caching result and retrying.", $" Begin 'leftRecursiveRule' at (1,3) with state key {stateKey}", $" Cache hit.", $" End 'leftRecursiveRule' with success at (1,5) with state key {stateKey}", $" Caching result and retrying.", $" Begin 'leftRecursiveRule' at (1,3) with state key {stateKey}", $" Cache hit.", $" End 'leftRecursiveRule' with success at (1,8) with state key {stateKey}", $" No forward progress made, current cache entry will be kept.", $" End 'leftRecursiveRule' with success at (1,8) with state key {stateKey}", $" Begin 'outerRule' at (1,8) with state key {stateKey}", $" Begin 'innerRule' at (1,8) with state key {stateKey}", $" End 'innerRule' with success at (1,10) with state key {stateKey}", $" End 'outerRule' with success at (1,10) with state key {stateKey}", $" Begin 'memoizedRule' at (1,10) with state key {stateKey}", $" Cache miss.", $" Caching result.", $" End 'memoizedRule' with success at (1,12) with state key {stateKey}", $" Begin 'memoizedRule' at (1,10) with state key {stateKey}", $" Cache hit.", $" End 'memoizedRule' with success at (1,12) with state key {stateKey}", $" Begin 'memoizedRule' at (1,12) with state key {stateKey}", $" Cache miss.", $" Caching result.", $" End 'memoizedRule' with failure at (1,12) with state key {stateKey}", $" Begin 'memoizedRule' at (1,12) with state key {stateKey}", $" Cache hit.", $" End 'memoizedRule' with failure at (1,12) with state key {stateKey}", $"End 'start' with success at (1,12) with state key {stateKey}"))); }
public void Parse_WhenACSharpExpressionDoesntConsumeAllOfTheSourceText_YieldsError() { var parser = new PegParser(); try { parser.Parse("a = {{ return \"OK\"; } extra }"); } catch (FormatException ex) { Assert.That(ex.Message, Is.StringStarting("PEG0011:")); var cursor = (Cursor)ex.Data["cursor"]; Assert.That(cursor.Location, Is.EqualTo(22)); } }
public void Parse_WithClassExpression_YieldsClassExpressionWithCorrectCharacterRanges() { var subject = "a = [-a-z0-9]"; var parser = new PegParser(); var grammar = parser.Parse(subject); var charClass = (ClassExpression)grammar.Rules.Single().Expression; var expected = new[] { new CharacterRange('-', '-'), new CharacterRange('a', 'z'), new CharacterRange('0', '9'), }; Assert.That(charClass.Ranges, Is.EquivalentTo(expected)); }
/// <summary> /// Parse and compile a PEG grammar from a string. /// </summary> /// <param name="subject">The PEG grammar to parse and compile.</param> /// <param name="fileName">The filename to use in errors.</param> /// <returns>A <see cref="CompileResult"/> containing the result of the compilation.</returns> public static CompileResult CompileString(string subject, string fileName = null) { Grammar grammar; try { grammar = new PegParser().Parse(subject ?? string.Empty, fileName); } catch (FormatException ex) { var cursor = ex.Data["cursor"] as Cursor; if (cursor != null && Regex.IsMatch(ex.Message, @"^PEG\d+:")) { var parts = ex.Message.Split(new[] { ':' }, 2); var result = new CompileResult(null); result.Errors.Add(new CompilerError(cursor.FileName ?? string.Empty, cursor.Line, cursor.Column, parts[0], parts[1])); return result; } throw; } return PegCompiler.Compile(grammar); }
public void GeneratedParser_Performance_Regression(string testName) { var parserSource = File.ReadAllText($@"TestCases\{testName}.peg"); var subject = File.ReadAllText($@"TestCases\{testName}.txt"); var parsed = new PegParser().Parse(parserSource); var compiled = PegCompiler.Compile(parsed); Assert.That(compiled.Errors.Where(e => !e.IsWarning), Is.Empty); var pegParser = CodeCompiler.Compile<dynamic>(compiled); Evaluate(() => { pegParser.Parse(subject); }); }
public void Compile_WithUnusedRules_YieldsWarning() { var grammar = new PegParser().Parse("a = b; b = 'OK'; c = d; d = 'OK' c;"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0017")); Assert.That(error.IsWarning, Is.True); }
public void Compile_WithUnrecognizedSetting_YieldsWarning() { var grammar = new PegParser().Parse("@barnacle OK; a = 'OK';"); var result = PegCompiler.Compile(grammar); var error = result.Errors.First(); Assert.That(error.ErrorNumber, Is.EqualTo("PEG0006")); Assert.That(error.IsWarning, Is.True); }