public void Rewrite_SpecialExpression2_TargetNodeCount() { var lexical = new LexicalAnalyzer(AnalyzerFacade.LexicalRules); var syntactic = new SyntacticAnalyzer(AnalyzerFacade.SyntacticRules); var translator = new Translator(AnalyzerFacade.TranslateRules); const string text = "(((-1+1+3+pi)))"; var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, BlockOf<ExpressionBlock>()); var root = translator.Rewrite(tree); Assert.That(root.Nodes.Count(), Is.EqualTo(2)); }
public void Rewrite_Expressiion_DoesNotThrow(string text) { var lexical = new LexicalAnalyzer(AnalyzerFacade.LexicalRules); var syntactic = new SyntacticAnalyzer(AnalyzerFacade.SyntacticRules); var translator = new Translator(AnalyzerFacade.TranslateRules); Assert.DoesNotThrow( () => { var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, BlockOf<ExpressionBlock>()); translator.Rewrite(tree); }); }
public void Translate_SpecialExpression2_TargetNodeCount() { var lexical = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules); var syntactic = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules); var translator = new Translator(StandardProcessorBuilder.TranslateRules); const string text = "(((-1+1+3+pi)))"; var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, StandardProcessorBuilder.SyntacticTarget); var result = translator.Translate(tree); Assert.That(result.Nodes.Count(), Is.EqualTo(2)); }
public void Parse_WrongRules_Throw() { const string pattern = @"^(?<e>[\s\S]*)$"; const string text = " a1vd bu "; var token = MockRepository.GenerateStub<IToken>(); var lexicalRule = MockRepository.GenerateStub<ILexicalRule>(); lexicalRule.Stub(r => r.Pattern).Return(pattern); lexicalRule.Stub(r => r.TokenFactory).Return(builder => token); var analyzer = new LexicalAnalyzer(new[] {lexicalRule}); analyzer.Parse(text); }
public void TranslateAndCheck_Expressiion_DoesNotThrow(string text) { var lexical = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules); var syntactic = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules); var translator = new Translator(StandardProcessorBuilder.TranslateRules); Assert.DoesNotThrow( () => { var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, StandardProcessorBuilder.SyntacticTarget); var result = translator.Translate(tree); translator.CheckResult(result); }); }
public void Resolve_UnresolverIdentifier_Throw(string text) { var lexical = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules); var syntactic = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules); var translator = new Translator(StandardProcessorBuilder.TranslateRules); var linkedLibraryFactory = new StaticLinkedLibraryFactory(typeof(StandardProcessorBuilder.LinkedMath)); var linker = new Linker(StandardProcessorBuilder.LinkerRules, linkedLibraryFactory.CreateLinkedLibrary()); var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, StandardProcessorBuilder.SyntacticTarget); var translatedTree = translator.Translate(tree); translator.CheckResult(translatedTree); linker.Resolve(translatedTree); }
public void Translate_SumOfProduct_SumTerm() { var lexical = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules); var syntactic = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules); var translator = new Translator(StandardProcessorBuilder.TranslateRules); const string text = "2*3+3*4.7"; var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, StandardProcessorBuilder.SyntacticTarget); var result = translator.Translate(tree); var termNode = (TermSyntacticNode) result; Assert.That(termNode.Term, Is.TypeOf<BinaryOperatorTerm>()); var operatorTerm = (BinaryOperatorTerm) termNode.Term; Assert.That(operatorTerm.Operator, Is.TypeOf<PlusOperator>()); }
public void Compile_Expressiion_RightResult(string text, double value) { var linkedLibraryFactory = new StaticLinkedLibraryFactory(typeof(StandardProcessorBuilder.LinkedMath)); var lexical = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules); var syntactic = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules); var translator = new Translator(StandardProcessorBuilder.TranslateRules); var linker = new Linker(StandardProcessorBuilder.LinkerRules, linkedLibraryFactory.CreateLinkedLibrary()); var tokens = lexical.Parse(text); var tree = syntactic.Parse(tokens, StandardProcessorBuilder.SyntacticTarget); var translatedTree = translator.Translate(tree); translator.CheckResult(translatedTree); var linkedTree = linker.Resolve(translatedTree); linker.CheckResult(linkedTree); var compilator = new Compiler(); var lambda = compilator.CreateExpression(linkedTree); var result = lambda.Compile()(); Assert.That(result, Is.EqualTo(value).Within(1e-1)); }
public void Parse_Text_TrueToken() { var analyzer = new LexicalAnalyzer(AnalyzerFacade.LexicalRules); const string text = "2 +3.3 + func(4,7)*u "; var tokens = analyzer.Parse(text).ToArray(); Assert.That(tokens.Length, Is.EqualTo(12)); Assert.That(tokens[0], Is.TypeOf<NumberToken>()); Assert.That(tokens[1], Is.TypeOf<OperatorToken>()); Assert.That(tokens[2], Is.TypeOf<NumberToken>()); Assert.That(tokens[3], Is.TypeOf<OperatorToken>()); Assert.That(tokens[4], Is.TypeOf<IdentifierToken>()); Assert.That(tokens[5], Is.TypeOf<LeftBracketToken>()); Assert.That(tokens[6], Is.TypeOf<NumberToken>()); Assert.That(tokens[7], Is.TypeOf<SeparatorToken>()); Assert.That(tokens[8], Is.TypeOf<NumberToken>()); Assert.That(tokens[9], Is.TypeOf<RightBracketToken>()); Assert.That(tokens[10], Is.TypeOf<BinaryOperatorToken>()); Assert.That(tokens[11], Is.TypeOf<IdentifierToken>()); }