public void Constructor_Rules_SameCount()
{
var lexicalRule = MockRepository.GenerateStub<ILexicalRule>();
lexicalRule.Stub(x => x.Pattern).Return("pattern");
var rules = new List<ILexicalRule> {lexicalRule, lexicalRule};
var analyzer = new LexicalAnalyzer(rules);
Assert.That(analyzer.Rules.Count(), Is.EqualTo(rules.Count));
}
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 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 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 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>());
}
public void GivenIHaveStandardLexicalAnSyntacticAnalyzers()
{
LexicalAnalyzer = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules);
SyntacticAnalyzer = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules);
}
public void SetUp()
{
LexicalAnalyzer = new LexicalAnalyzer(AnalyzerFacade.LexicalRules);
SyntacticAnalyzer = new SyntacticAnalyzer(AnalyzerFacade.SyntacticRules);
}
public void SetUp()
{
Analyzer = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules);
}
public void SetUp()
{
LexicalAnalyzer = new LexicalAnalyzer(StandardProcessorBuilder.LexicalRules);
SyntacticAnalyzer = new SyntacticAnalyzer(StandardProcessorBuilder.SyntacticRules);
}
public void SetUp()
{
Analyzer = new LexicalAnalyzer(AnalyzerFacade.LexicalRules);
}
public void GivenIHaveStandardLexicalAnSyntacticAnalyzers()
{
LexicalAnalyzer = new LexicalAnalyzer(AnalyzerFacade.LexicalRules);
SyntacticAnalyzer = new SyntacticAnalyzer(AnalyzerFacade.SyntacticRules);
}
