public void Rewriter_TwoTrueRules_LastRuleResult()
{
var tree = MockRepository.GenerateStub<ISyntacticNode>();
tree.Stub(t => t.Nodes).Return(Enumerable.Empty<ISyntacticNode>());
tree.Stub(t => t.Rewrite(Arg<IEnumerable<ISyntacticNode>>.Is.Anything))
.Return(tree);
var tree1 = MockRepository.GenerateStub<ISyntacticNode>();
tree1.Stub(t => t.Nodes).Return(Enumerable.Empty<ISyntacticNode>());
tree1.Stub(t => t.Rewrite(Arg<IEnumerable<ISyntacticNode>>.Is.Anything))
.Return(tree1);
var rule1 = MockRepository.GenerateStub<ISyntaxRewriter>();
rule1.Stub(r => r.Filter(tree)).Return(true);
rule1.Stub(r => r.Visit(Arg<ISyntacticNode>.Is.Anything,
Arg<IEnumerable<ISyntacticNode>>.Is.Anything)).Return(tree1);
var tree2 = MockRepository.GenerateStub<ISyntacticNode>();
var rule2 = MockRepository.GenerateStub<ISyntaxRewriter>();
rule2.Stub(r => r.Filter(tree1)).Return(true);
rule2.Stub(r => r.Visit(Arg<ISyntacticNode>.Is.Anything,
Arg<IEnumerable<ISyntacticNode>>.Is.Anything)).Return(tree2);
var translator = new Translator(new[] { rule1, rule2 });
Assert.That(translator.Rewrite(tree), Is.SameAs(tree2));
}
public void CheckResult_BlockNode_Throw()
{
var node = new BlockSyntacticNode(
MockRepository.GenerateStub<IBlock>(),
Enumerable.Empty<ISyntacticNode>());
var translator = new Translator(Enumerable.Empty<ISyntaxRewriter>());
translator.CheckResult(node);
}
public void CheckResult_TermNode_DoesNotThrow()
{
var node = new TermSyntacticNode(
MockRepository.GenerateStub<ITerm>(),
Enumerable.Empty<ISyntacticNode>());
var translator = new Translator(Enumerable.Empty<ISyntaxRewriter>());
Assert.DoesNotThrow(() => translator.CheckResult(node));
}
public void Rules_SomeList_Same()
{
var rules = new[]
{
MockRepository.GenerateStub<ISyntaxRewriter>(),
MockRepository.GenerateStub<ISyntaxRewriter>()
};
var translator = new Translator(rules);
Assert.That(translator.Rules, Is.SameAs(rules));
}
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 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 Rules_Empty_Empty()
{
var rules = Enumerable.Empty<ISyntaxRewriter>();
var translator = new Translator(rules);
Assert.That(translator.Rules, Is.SameAs(rules));
}
public void Rules_Null_Null()
{
var translator = new Translator(null);
Assert.That(translator.Rules, Is.Null);
}
