public void Basic_definition_test() { var testPattern = "<sub_fragment><#sub_variable><%12><@branch-context>" + "<$branch_Variable>|{this is some$contentwith!$oDDcharacterz}<^sub_pattern>"; var patternLexer = new PatternLexer(new Lexer()); patternLexer.Initialize(); var results = patternLexer.Process(testPattern).ToArray(); Assert.That(results.Count(), Is.EqualTo(10)); Assert.That(results[0].Type, Is.EqualTo(TokenType.TAG_SUB_FRAGMENT)); Assert.That(results[0].Value, Is.EqualTo("<sub_fragment>")); Assert.That(results[1].Type, Is.EqualTo(TokenType.TAG_SUB_VARIABLE)); Assert.That(results[1].Value, Is.EqualTo("<#sub_variable>")); Assert.That(results[2].Type, Is.EqualTo(TokenType.TAG_BRANCH_CHANCE)); Assert.That(results[2].Value, Is.EqualTo("<%12>")); Assert.That(results[3].Type, Is.EqualTo(TokenType.TAG_BRANCH_CONTEXT)); Assert.That(results[3].Value, Is.EqualTo("<@branch-context>")); Assert.That(results[4].Type, Is.EqualTo(TokenType.TAG_BRANCH_VARIABLE)); Assert.That(results[4].Value, Is.EqualTo("<$branch_Variable>")); Assert.That(results[5].Type, Is.EqualTo(TokenType.TAG_ELSE)); Assert.That(results[5].Value, Is.EqualTo("|")); Assert.That(results[6].Type, Is.EqualTo(TokenType.BRANCH_START)); Assert.That(results[6].Value, Is.EqualTo("{")); Assert.That(results[7].Type, Is.EqualTo(TokenType.CONTENT)); Assert.That(results[7].Value, Is.EqualTo("this is some$contentwith!$oDDcharacterz")); Assert.That(results[8].Type, Is.EqualTo(TokenType.BRANCH_END)); Assert.That(results[8].Value, Is.EqualTo("}")); Assert.That(results[9].Type, Is.EqualTo(TokenType.TAG_SUB_PATTERN)); Assert.That(results[9].Value, Is.EqualTo("<^sub_pattern>")); }
public void Process_replaces_variable_tags() { var testPattern = "pre<#var1>mid<#var2>post"; var variable1Value = _fixture.Create <string>(); var variable2Value = _fixture.Create <string>(); var expectedResult = "pre" + variable1Value + "mid" + variable2Value + "post"; var mockNamelistSource = new Mock <INamelistSource>(); var lexer = new PatternLexer(new SimpleLexer.Lexer()); var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>()); parser.Initialize(); var variables = new Dictionary <string, string>(); variables.Add("var1", variable1Value); variables.Add("var2", variable2Value); var parameters = new PatternProcessingParameters(testPattern) { Variables = variables }; var result = parser.Process(parameters); Assert.That(result, Is.EqualTo(expectedResult)); }
public void Somewhat_complex_pattern() { var testPattern = "front<%50>{middle}end"; var patternLexer = new PatternLexer(new Lexer()); patternLexer.Initialize(); var results = patternLexer.Process(testPattern).ToArray(); Assert.That(results.Count(), Is.EqualTo(6)); Assert.That(results[0].Type, Is.EqualTo(TokenType.CONTENT)); Assert.That(results[0].Value, Is.EqualTo("front")); Assert.That(results[1].Type, Is.EqualTo(TokenType.TAG_BRANCH_CHANCE)); Assert.That(results[1].Value, Is.EqualTo("<%50>")); Assert.That(results[2].Type, Is.EqualTo(TokenType.BRANCH_START)); Assert.That(results[2].Value, Is.EqualTo("{")); Assert.That(results[3].Type, Is.EqualTo(TokenType.CONTENT)); Assert.That(results[3].Value, Is.EqualTo("middle")); Assert.That(results[4].Type, Is.EqualTo(TokenType.BRANCH_END)); Assert.That(results[4].Value, Is.EqualTo("}")); Assert.That(results[5].Type, Is.EqualTo(TokenType.CONTENT)); Assert.That(results[5].Value, Is.EqualTo("end")); }
public void Initialize_loads_token_definitions_into_internal_lexer() { var mockLexer = new Mock <ILexer>(); var patternLexer = new PatternLexer(mockLexer.Object); patternLexer.Initialize(); mockLexer.Verify(x => x.AddDefinition(It.IsAny <TokenDefinition>())); }
public void Process_correctly_handles_nested_branching(bool takeOuterBranch, bool takeInnerBranch) { var testPattern = "front<@outer>{middle<@inner>{deep}}end"; var expectedTakeJustOutsideBranch = "frontmiddleend"; var expectedTakeAllBranch = "frontmiddledeepend"; var expectedIgnoreBranch = "frontend"; var mockNamelistSource = new Mock <INamelistSource>(); var context = new List <string>(); if (takeOuterBranch) { context.Add("outer"); } if (takeInnerBranch) { context.Add("inner"); } var lexer = new PatternLexer(new SimpleLexer.Lexer()); var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>()); parser.Initialize(); var parameters = new PatternProcessingParameters(testPattern) { Context = context }; var result = parser.Process(parameters); if (takeOuterBranch) { if (takeInnerBranch) { Assert.That(result, Is.EqualTo(expectedTakeAllBranch)); } else { Assert.That(result, Is.EqualTo(expectedTakeJustOutsideBranch)); } } else { Assert.That(result, Is.EqualTo(expectedIgnoreBranch)); } }
public void Process_rethrows_exceptions_generated_by_internal_lexer() { var mockLexer = new Mock <ILexer>(); mockLexer .Setup(x => x.Tokenize(It.IsAny <string>())) .Throws(new Exception()); var patternLexer = new PatternLexer(mockLexer.Object); patternLexer.Initialize(); Assert.Throws <PatternParseException>( () => patternLexer.Process(_fixture.Create <string>())); }
public void Process_returns_tokens_from_internal_lexer_without_end_token() { var tokenValues = _fixture.CreateMany <string>(); var rawTokens = new List <Token>(); foreach (var value in tokenValues) { rawTokens.Add(new Token( _fixture.Create <TokenType>().ToString(), value, _fixture.Create <TokenPosition>())); } rawTokens.Add(new Token("(end)", null, _fixture.Create <TokenPosition>())); var testPattern = _fixture.Create <string>(); var mockLexer = new Mock <ILexer>(); mockLexer .Setup(x => x.Tokenize(testPattern)) .Returns(rawTokens); var patternLexer = new PatternLexer(mockLexer.Object); patternLexer.Initialize(); var results = patternLexer.Process(testPattern).ToArray(); Assert.That(results.Count(), Is.EqualTo(rawTokens.Count() - 1)); for (int i = 0; i < rawTokens.Count - 1; i++) { var raw = rawTokens[i]; var processed = results[i]; Assert.That(processed.Type.ToString(), Is.EqualTo(raw.Type)); Assert.That(processed.Value, Is.EqualTo(raw.Value)); Assert.That(processed.SourceIndex, Is.EqualTo(raw.Position.Index)); } }
public void Process_correctly_handles_branching_by_chance() { var testPattern = "front<%50>{middle}end"; var expectedTakeBranch = "frontmiddleend"; var expectedIgnoreBranch = "frontend"; var mockNamelistSource = new Mock <INamelistSource>(); var lexer = new PatternLexer(new SimpleLexer.Lexer()); var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>()); parser.Initialize(); var parameters = new PatternProcessingParameters(testPattern); var result = parser.Process(parameters); //TODO try asserting that each is taken roughly half the time out of many tries Assert.That(result, Is.EqualTo(expectedTakeBranch).Or.EqualTo(expectedIgnoreBranch)); }
public void Process_correctly_handles_branching_by_variable(bool takeBranch) { var testPattern = "front<$var1>{middle}end"; var expectedTakeBranch = "frontmiddleend"; var expectedIgnoreBranch = "frontend"; var mockNamelistSource = new Mock <INamelistSource>(); var variables = new Dictionary <string, string>(); if (takeBranch) { variables.Add("var1", _fixture.Create <string>()); } var lexer = new PatternLexer(new SimpleLexer.Lexer()); var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>()); parser.Initialize(); var parameters = new PatternProcessingParameters(testPattern) { Variables = variables }; var result = parser.Process(parameters); if (takeBranch) { Assert.That(result, Is.EqualTo(expectedTakeBranch)); } else { Assert.That(result, Is.EqualTo(expectedIgnoreBranch)); } }