public void FeatureMatcherGeneratesCorrectTypeNameInDescription()
{
var sut = Describe.Object <AnotherFlatClass>()
.Property(x => x.Id, new FakeMatcher <Guid>(true, "", i => ""));
sut.ShouldHaveDescription(Starts.With("a(n) AnotherFlatClass where:"));
}
public void It_Can_Handle_Recursive_Rules()
{
IRuleParser ListParser()
{
var list = new List <string>();
return(Starts.With
(
A.Word(list.Add),
One.Of
(
The.Symbol("}"),
A.Rule <List <string> >(ListParser, rest => list.AddRange(rest))
)
).ReturnsNode(list));
}
var parser = ListParser();
string src = "a b c d e f g}";
var tokens = new Lexer().ToTokens(src);
var resultList = parser
.FeedAll(tokens)
.AssertComplete <List <string> >();
var expectedList = new string[] { "a", "b", "c", "d", "e", "f", "g" };
Assert.Equal(expectedList, resultList);
}
public void FeatureMatcherGeneratesCorrectTypeNameInMismatchDescription()
{
var sut = Describe.Object <AnotherFlatClass>()
.Property(x => x.Id, new FakeMatcher <Guid>(false, "", i => ""));
sut.ShouldHaveMismatchDescriptionForValue(new AnotherFlatClass(), Starts.With("was a(n) AnotherFlatClass where:"));
}
public void No_match_if_string_does_not_end_with_substring()
{
var matcher = Starts.With("bob");
var matches = matcher.Matches("the cat sat on the mat");
Assert.That(matches, Is.False());
}
public void Describe_to()
{
var matcher = Starts.With("bob");
var description = new StringDescription();
matcher.DescribeTo(description);
Assert.That(description.ToString(), Is.EqualTo("a string starting with \"bob\""));
}
public void Describe_mismatch()
{
var matcher = Starts.With("bob");
var description = new StringDescription();
matcher.DescribeMismatch("the cat sat on the mat", description);
Assert.That(description.ToString(), Is.EqualTo("was \"the cat sat on the mat\""));
}
public void Describe_mismatch_if_thrown_exception_does_not_match_predicate()
{
var matcher = new ThrowsMatcher <ArgumentNullException>().With(e => e.Message == "something else");
var description = new StringDescription();
matcher.DescribeMismatch(DoIt, description);
NHAssert.That(description.ToString(), Starts.With("the exception was of the correct type, but did not match the predicate"));
}
public void Describe_mismatch_if_action_throws_different_exception()
{
var matcher = new ThrowsMatcher <NullReferenceException>();
var description = new StringDescription();
matcher.DescribeMismatch(DoIt, description);
NHAssert.That(description.ToString(), Starts.With("an exception of type System.ArgumentNullException was thrown"));
}
public void You_Can_Compose_Multiple_Rules()
{
var funcDef = new FunctionDefinition();
var classDef = new ClassDefinition();
classDef.Functions = new List <FunctionDefinition>();
var funcParser = Starts
.With
(
The.Keyword("function"),
A.Word(n => funcDef.Name = n),
The.Symbol("("),
The.Symbol(")"),
The.Symbol("{"),
The.Symbol("}")
)
.ReturnsNode(funcDef);
var classParser = Starts
.With
(
The.Keyword("class"),
A.Word(n => classDef.Name = n),
The.Symbol("{"),
A.Rule <FunctionDefinition>(() => funcParser, classDef.Functions.Add),
The.Symbol("}")
)
.ReturnsNode(classDef);
// Generate some tokens to parse with the parser we just made
string src =
@"
class FooBar
{
function DoThing() {}
}
";
var tokens = new Lexer().ToTokens(src).ToArray();
var result = classParser.FeedAll(tokens);
// Assert that it correctly did stuff.
result.AssertComplete();
Assert.Equal(classDef, result.node);
Assert.Equal("FooBar", classDef.Name);
Assert.Contains(funcDef, classDef.Functions);
Assert.Equal("DoThing", funcDef.Name);
}
public void One_Of_Works()
{
IRuleParser AlphabetParser()
{
return(Starts
.With
(
The.Word("a"),
The.Word("b"),
The.Word("c"),
The.Word("d")
)
.ReturnsNode("abcd"));
}
IRuleParser AberahamParser()
{
return(Starts
.With
(
The.Word("a"),
The.Word("b"),
The.Word("e"),
The.Word("raham") // laziness
)
.ReturnsNode("aberaham"));
}
var node = new TestNode();
var oneOfParser = Starts
.With
(
One.Of
(
A.Rule <string>(AlphabetParser, t => node.name = t),
A.Rule <string>(AberahamParser, t => node.name = t)
)
)
.ReturnsNode(node);
string src = "a b e raham";
var tokens = new Lexer().ToTokens(src);
var result = oneOfParser.FeedAll(tokens);
var resultNode = result.AssertComplete <TestNode>();
Assert.Equal(node, resultNode);
Assert.Equal("aberaham", resultNode.name);
}
public void You_Can_Express_An_Empty_Class()
{
var classDef = new ClassDefinition();
var classParser = Starts
.With
(
The.Keyword("class"),
A.Word(name => classDef.Name = name),
The.Symbol("{"),
The.Symbol("}")
)
.ReturnsNode(classDef);
// Generate some tokens to parse with the parser we just made
string src = "class FooBar {}";
var tokens = new Lexer().ToTokens(src);
var result = classParser.FeedAll(tokens);
// Assert that it correctly did stuff.
result.AssertComplete();
Assert.Equal(classDef, result.node);
Assert.Equal("FooBar", classDef.Name);
}
public void Match_if_string_ends_with_substring()
{
Assert.That("the cat sat on the mat", Starts.With("the"));
}
public void Case_insensitive_match_if_string_ends_with_substring()
{
Assert.That("the cat sat on the mat", Starts.With("The").CaseInsensitive());
}
