public void Process_replaces_by_context_properly(bool useProperContext)
{
var testPattern = "pre<replaceme>post";
var properContext = _fixture.CreateMany <string>();
var improperContext = _fixture.CreateMany <string>();
var properReplacement = _fixture.Create <string>();
var improperReplacement = _fixture.Create <string>();
var properExpression = new Mock <IContextExpression>();
properExpression.Setup(x => x.Matches(properContext)).Returns(true);
var improperExpression = new Mock <IContextExpression>();
improperExpression.Setup(x => x.Matches(improperContext)).Returns(true);
var namelist = new Namelist("replaceme");
namelist.AddFragment(new NameFragment(properReplacement, properExpression.Object));
namelist.AddFragment(new NameFragment(improperReplacement, improperExpression.Object));
var expectedResult = "";
IEnumerable <string> context;
if (useProperContext)
{
context = properContext;
expectedResult = "pre" + properReplacement + "post";
}
else
{
context = improperContext;
expectedResult = "pre" + improperReplacement + "post";
}
var mockNamelistSource = new Mock <INamelistSource>();
mockNamelistSource
.Setup(x => x.GetNamelist("replaceme"))
.Returns(namelist);
var lexer = new PatternLexer(new SimpleLexer.Lexer());
var parameters = new PatternProcessingParameters(testPattern)
{
Context = context
};
var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>());
parser.Initialize();
var result = parser.Process(parameters);
Assert.That(result, Is.EqualTo(expectedResult));
}
public void Process_handles_uniqueness_check_properly()
{
var testPattern = "<replaceme>";
var replacements = _fixture.CreateMany <string>();
var namelist = new Namelist("replaceme");
var expression = new Mock <IContextExpression>();
expression.Setup(x => x.Matches(It.IsAny <IEnumerable <string> >())).Returns(true);
foreach (var replacement in replacements)
{
namelist.AddFragment(new NameFragment(replacement, expression.Object));
}
var mockNamelistSource = new Mock <INamelistSource>();
mockNamelistSource
.Setup(x => x.GetNamelist("replaceme"))
.Returns(namelist);
var lexer = new PatternLexer(new SimpleLexer.Lexer());
var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>());
parser.Initialize();
var results = new List <string>();
PatternProcessingParameters parameters;
for (int i = 0; i < replacements.Count(); i++)
{
parameters = new PatternProcessingParameters(testPattern)
{
UniqueCheck = results
};
results.Add(parser.Process(parameters));
}
parameters = new PatternProcessingParameters(testPattern)
{
UniqueCheck = results
};
Assert.Throws <PatternParseException>(
() => parser.Process(parameters));
foreach (var replacement in replacements)
{
Assert.That(results.Where(x => x == replacement).Count() == 1);
}
}
public void Subpatterns_are_processed_before_being_substituted()
{
var expression = new Mock <IContextExpression>();
expression.Setup(x => x.Matches(It.IsAny <IEnumerable <string> >())).Returns(true);
var subPattern = "<first> and then the <second>";
var pattern = "<^sub_pattern> and then some more <first>";
var expected = "first_sub and then the second_sub and then some more first_sub";
var subPatternNamelist = new Namelist("sub_pattern");
subPatternNamelist.AddFragment(new NameFragment(subPattern, expression.Object));
var firstNamelist = new Namelist("first");
firstNamelist.AddFragment(new NameFragment("first_sub", expression.Object));
var secondNamelist = new Namelist("second");
secondNamelist.AddFragment(new NameFragment("second_sub", expression.Object));
var mockNamelistSource = new Mock <INamelistSource>();
mockNamelistSource
.Setup(x => x.GetNamelist("sub_pattern"))
.Returns(subPatternNamelist);
mockNamelistSource
.Setup(x => x.GetNamelist("first"))
.Returns(firstNamelist);
mockNamelistSource
.Setup(x => x.GetNamelist("second"))
.Returns(secondNamelist);
var parser = new NameParser(mockNamelistSource.Object, 0);
parser.Initialize();
var parameters = new PatternProcessingParameters(pattern);
var result = parser.Process(parameters);
Assert.That(result, Is.EqualTo(expected));
}
public void Process_honors_capitalization_by_sentence()
{
var expression = new Mock <IContextExpression>();
expression.Setup(x => x.Matches(It.IsAny <IEnumerable <string> >())).Returns(true);
var firstNamelist = new Namelist("first_part");
var firstReplacement = "first";
firstNamelist.AddFragment(new NameFragment(firstReplacement, expression.Object));
var secondNamelist = new Namelist("second_part");
var secondReplacement = "second";
secondNamelist.AddFragment(new NameFragment(secondReplacement, expression.Object));
var testPattern = "some begining <first_part> and then. sOME more <second_part> mIxeD CASe";
var expectedResult = "Some begining first and then. SOME more second mIxeD CASe";
var mockNamelistSource = new Mock <INamelistSource>();
mockNamelistSource
.Setup(x => x.GetNamelist("first_part"))
.Returns(firstNamelist);
mockNamelistSource
.Setup(x => x.GetNamelist("second_part"))
.Returns(secondNamelist);
var lexer = new PatternLexer(new SimpleLexer.Lexer());
var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>());
parser.Initialize();
var parameters = new PatternProcessingParameters(testPattern)
{
CapitalizationScheme = CapitalizationScheme.BY_SENTENCE
};
var result = parser.Process(parameters);
Assert.That(result, Is.EqualTo(expectedResult));
}
public void Process_correctly_subsitutes_fragments_in_simple_pattern()
{
var testPattern = "<first_part><second_part>";
var expression = new Mock <IContextExpression>();
expression.Setup(x => x.Matches(It.IsAny <IEnumerable <string> >())).Returns(true);
var firstNamelist = new Namelist("first_part");
var firstReplacement = _fixture.Create <string>();
firstNamelist.AddFragment(new NameFragment(firstReplacement, expression.Object));
var secondNamelist = new Namelist("second_part");
var secondReplacement = _fixture.Create <string>();
secondNamelist.AddFragment(new NameFragment(secondReplacement, expression.Object));
var expectedResult = firstReplacement + secondReplacement;
var lexer = new PatternLexer(new SimpleLexer.Lexer());
var mockNamelistSource = new Mock <INamelistSource>();
mockNamelistSource
.Setup(x => x.GetNamelist("first_part"))
.Returns(firstNamelist);
mockNamelistSource
.Setup(x => x.GetNamelist("second_part"))
.Returns(secondNamelist);
var parser = new NameParser(mockNamelistSource.Object, lexer, _fixture.Create <int>());
parser.Initialize();
var parameters = new PatternProcessingParameters(testPattern);
var result = parser.Process(parameters);
Assert.That(result, Is.EqualTo(expectedResult));
}
