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));
}
}
