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 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 Compile_WithInvalidSettingValue_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"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WithDuplicateDefinition_YieldsError()
{
var grammar = new PegParser().Parse("a = 'a'; a = 'b';");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0002"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WithDuplicateSetting_YieldsError(string settingName)
{
var grammar = new PegParser().Parse("@" + settingName + " OK; @" + settingName + " OK; a = 'OK';");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0005"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WhenTheGrammarUsesAnUnknownFlag_YieldsWarning()
{
var grammar = new PegParser().Parse("a -unknown = 'OK'");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0013"));
Assert.That(error.IsWarning, Is.True);
}
public void Compile_WithAnImpossibleQuantifier_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 Compile_WhenTheGrammarRepeatsAZeroWidthExpressionWithNoMaximum_YieldsError()
{
var grammar = new PegParser().Parse("a = ''*");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.First();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0021"));
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 Compile_WhenTheGrammarRepeatsAZeroWidthExpressionContainingAnAssertionWithFiniteMaximum_YieldsWarning()
{
var grammar = new PegParser().Parse("a = (&{false} '')<1,5>");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.First();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0022"));
Assert.That(error.IsWarning, Is.True);
}
public void Compile_WithMissingStartRule_YieldsError()
{
var grammar = new PegParser().Parse("@start b; a = 'OK'");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0003"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WithNoRules_YieldsError()
{
var grammar = new PegParser().Parse(" ");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0001"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WhenTheGrammarRepeatsALabel_YieldsError()
{
var grammar = new PegParser().Parse("a = foo:'OK' foo:'OK'");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0007"));
Assert.That(error.IsWarning, Is.False);
}
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);
}
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 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 Compile_WhenTheGrammarHasResourceStringWithoutResourcesSpecified_YieldsError()
{
var grammar = new PegParser().Parse("a = 'OkResource'r");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0016"));
Assert.That(error.IsWarning, Is.False);
}
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_WhenTheGrammarRepeatsAParseCodeExpressionWithNoMaximum_YieldsWarning(string subject, string errorNumber)
{
var grammar = new PegParser().Parse(subject);
var result = PegCompiler.Compile(grammar);
var error = result.Errors.First();
Assert.That(error.ErrorNumber, Is.EqualTo(errorNumber));
Assert.That(error.IsWarning, Is.True);
}
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_WithPublicOrExportedRulesWithLowercaseName_YieldsWarning(string flag)
{
var grammar = new PegParser().Parse($"start = 'OK'; b {flag} = 'OK';");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0025"));
Assert.That(error.IsWarning, Is.True);
}
public void Compile_WhenTheGrammarHasTwoNestedLexicalRules_ProducesAParserThatReturnsBothLexicalElements()
{
var grammar = new PegParser().Parse("a -lexical = ' ' b ' '; b -lexical = 'OK';");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
var result = parser.Parse(" OK ", null, out var lexicalElements);
var actual = lexicalElements.Select(e => e.Name + "@" + e.StartCursor.Location + ":" + e.EndCursor.Location).ToArray();
Assert.That(actual, Is.EqualTo(new[] { "b@1:3", "a@0:4" }));
}
public void Compile_WhenTheGrammarHasLexicalRuleConsistingOfAWildcardExpression_ProducesAParserThatReturnsTheLexicalElements()
{
var grammar = new PegParser().Parse("a -lexical = .;");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
var result = parser.Parse("OK", null, out var lexicalElements);
var actual = lexicalElements.Select(e => e.Name + "@" + e.StartCursor.Location + ":" + e.EndCursor.Location).ToArray();
Assert.That(actual, Is.EqualTo(new[] { "a@0:1" }));
}
public void Compile_WithUnmemoizedLeftRecursion_YieldsError(string subject)
{
var parser = new PegParser();
var grammar = parser.Parse(subject);
var result = PegCompiler.Compile(grammar);
var error = result.Errors.First();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0020"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WithExpressionWhoseTypeIsNotDefined_YieldsError()
{
var parser = new PegParser();
var grammar = parser.Parse("a -memoize = a;");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0019"));
Assert.That(error.IsWarning, Is.False);
}
public void Compile_WhenTheGrammarHasTwoLexicalRulesThatBeginAndEndOnTheSameCharacter_ProducesAParserThatReturnsBothLexicalElements()
{
var grammar = new PegParser().Parse("a -lexical = b; b -lexical = 'OK';");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
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[] { "b@0:2", "a@0:2" }));
}
public void Compile_ForAllFoundTutorials_Succeeds(
[ValueSource(nameof(Tutorials))] Tutorial tutorial,
[ValueSource(nameof(Cultures))] string culture)
{
CultureUtilities.WithCulture(culture, () =>
{
var grammar = new PegParser().Parse(tutorial.GrammarText);
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
});
}
public void Parse_For05Calculator_ThrowsForInvalidFormats(
[Values("5,7+8,9*42")] string expression,
[ValueSource(nameof(Cultures))] string culture)
{
CultureUtilities.WithCulture(culture, () =>
{
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);
Assert.Throws <FormatException>(() => parser.Parse(expression));
});
}
public void Parse_WhenUsingLojbhan_DoesntTimeOut(string subject)
{
var parserSource = File.ReadAllText(@"TestCases\LojbanGrammar.peg");
var grammar = new PegParser().Parse(parserSource, @"TestCases\LojbanGrammar.peg");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <object>(compiled);
Assert.That(parser.Parse(subject), Is.EqualTo(subject));
Evaluate(() =>
{
var x = parser.Parse(subject);
});
}
public void Parse_ForAllFoundTutorials_Succeeds(
[ValueSource(nameof(Tutorials))] Tutorial tutorial,
[ValueSource(nameof(Cultures))] string culture)
{
CultureUtilities.WithCulture(culture, () =>
{
var grammar = new PegParser().Parse(tutorial.GrammarText);
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <object>(compiled);
var result = parser.Parse(tutorial.TestText);
Assert.That(result, Is.Not.Null);
});
}
