public void CloseBlockStatementShouldSetParentToTopParent()
{
ClassStatement classStatement = StatementCreator.CreateClassStatement();
_manager.Encountered(new[] { classStatement }, TokenCreator.Created().Count(), TokenCreator.Created());
OpenBlockStatement openBlock = StatementCreator.CreateOpenBlockStatement();
_manager.Encountered(new[] { openBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
ClassStatement internalClassStatement = StatementCreator.CreateClassStatement();
_manager.Encountered(new[] { internalClassStatement }, TokenCreator.Created().Count(), TokenCreator.Created());
OpenBlockStatement secondOpenBlock = StatementCreator.CreateOpenBlockStatement();
_manager.Encountered(new[] { secondOpenBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
CloseBlockStatement closeBlock = StatementCreator.CreateCloseBlockStatement();
CollectionAssert.AreEquivalent(new[] { new StatementParent(new[] { classStatement }, openBlock), new StatementParent(new[] { internalClassStatement }, secondOpenBlock) }, _manager.GetContext(closeBlock.Tokens).Parents);
_manager.Encountered(new[] { closeBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
CollectionAssert.AreEquivalent(new[] { new StatementParent(new[] { classStatement }, openBlock) }, _manager.GetContext(openBlock.Tokens).Parents);
_manager.Encountered(new[] { closeBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
}
public void NextTokenShouldNotReturnWhiteSpaceToken()
{
TokenBase identifier = TokenCreator.Create <IdentifierToken>("test");
TokenBase space = TokenCreator.Create <SpaceToken>();
StatementBase classStatement = StatementCreator.CreateClassStatement();
StatementBase memberStatement = StatementCreator.CreateMemberStatement("test");
IList <TokenBase> totalList = new List <TokenBase>();
foreach (TokenBase aToken in classStatement.Tokens)
{
totalList.Add(aToken);
}
foreach (TokenBase aToken in memberStatement.Tokens)
{
totalList.Add(aToken);
}
totalList.Add(space);
totalList.Add(identifier);
IList <TokenBase> identifierList = new List <TokenBase>();
identifierList.Add(space);
identifierList.Add(identifier);
_manager.Encountered(new[] { classStatement }, classStatement.Tokens.Count(), totalList);
Assert.AreEqual(identifier, _manager.GetContext(memberStatement.Tokens).NextTokenFromCurrentStatement);
}
public void CommentTextShouldReturnTextWithoutForwardSlashes()
{
String commentText = "a comment";
LineCommentStatement comment = StatementCreator.CreateLineCommentStatement("// " + commentText);
Assert.AreEqual(" a comment", comment.CommentText);
}
public void FileBlockFactoryReturnedBlockStatementsShouldBeAllStatements()
{
IList <StatementBase> input = new List <StatementBase>();
input.Add(StatementCreator.CreateMemberStatement("_this"));
input.Add(StatementCreator.CreateMemberStatement("_that"));
CollectionAssert.AreEquivalent(input, _factory.Create(input).ElementAt(0).Statements);
}
public void OpenBlockStatementForClassShouldSetParentContextToClass()
{
ClassStatement classStatement = StatementCreator.CreateClassStatement();
_manager.Encountered(new[] { classStatement }, TokenCreator.Created().Count(), TokenCreator.Created());
Assert.AreEqual(0, _manager.GetContext(classStatement.Tokens).Parents.Count());
OpenBlockStatement openBlock = StatementCreator.CreateOpenBlockStatement();
_manager.Encountered(new[] { openBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
Assert.AreEqual(new [] { new StatementParent(new[] { classStatement }, openBlock) }, _manager.GetContext(openBlock.Tokens).Parents);
}
public void StatementParentsShouldBeEqual()
{
StatementBase alphaStatement = StatementCreator.CreateMemberStatement("test");
StatementBase alphaDelimiter = StatementCreator.CreateOpenBlockStatement();
TokenCreator.Reset();
StatementBase bravoStatement = StatementCreator.CreateMemberStatement("test");
StatementBase bravoDelimiter = StatementCreator.CreateOpenBlockStatement();
StatementParent alpha = new StatementParent(new[] { alphaStatement }, alphaDelimiter);
StatementParent bravo = new StatementParent(new[] { bravoStatement }, bravoDelimiter);
Assert.AreEqual(alpha, bravo);
}
public void MemberStatementShouldNotRequireAccessModifier()
{
Expect.Call(_context.Parents).Return(new[] { new StatementParent(StatementCreator.CreateClassStatement(), StatementCreator.CreateOpenBlockStatement()) }).Repeat.Once();
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <IdentifierToken>("String"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("t"));
input.Add(TokenCreator.Create <SemiColonToken>());
Mocker.ReplayAll();
Assert.IsTrue(_factory.CanCreateStatementFrom(input, _context));
Mocker.VerifyAll();
}
public void StatementContextsShouldBeEqual()
{
IList <StatementParent> alphaList = new[] { new StatementParent(new[] { StatementCreator.CreateLineCommentStatement("test") }, null) };
TokenBase alphaNext = TokenCreator.Create <SemiColonToken>();
TokenCreator.Reset();
IList <StatementParent> bravoList = new[] { new StatementParent(new[] { StatementCreator.CreateLineCommentStatement("test") }, null) };
TokenBase bravoNext = TokenCreator.Create <SemiColonToken>();
StatementContext alpha = new StatementContext(alphaList, alphaNext);
StatementContext bravo = new StatementContext(bravoList, bravoNext);
Assert.AreEqual(alpha, bravo);
}
public void MemberStatementFactoryShouldNotCreateClass()
{
Expect.Call(_context.Parents).Return(new[] { new StatementParent(StatementCreator.CreateClassStatement(), StatementCreator.CreateOpenBlockStatement()) }).Repeat.Once();
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <PrivateModifierToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <ClassToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("t"));
Mocker.ReplayAll();
Assert.IsFalse(_factory.CanCreateStatementFrom(input, _context));
Mocker.VerifyAll();
}
public void EventShouldNotParseAsMember()
{
Expect.Call(_context.Parents).Return(new[] { new StatementParent(StatementCreator.CreateClassStatement(), StatementCreator.CreateOpenBlockStatement()) }).Repeat.Once();
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <EventToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("EventHandler"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("t"));
input.Add(TokenCreator.Create <SemiColonToken>());
Mocker.ReplayAll();
Assert.IsFalse(_factory.CanCreateStatementFrom(input, _context));
Mocker.VerifyAll();
}
public void MethodStatementFactoryShouldCreateMethodWithValueTypeReturnToken()
{
Expect.Call(_context.Parents).Return(new[] { new StatementParent(StatementCreator.CreateClassStatement(), StatementCreator.CreateOpenBlockStatement()) }).Repeat.Once();
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <PrivateModifierToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <ValueTypeToken>("bool"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("t"));
input.Add(TokenCreator.Create <OpenRoundBracketToken>());
input.Add(TokenCreator.Create <CloseRoundBracketToken>());
Mocker.ReplayAll();
Assert.IsTrue(_factory.CanCreateStatementFrom(input, _context));
Mocker.VerifyAll();
}
public void RuleShouldAllowHeaderToBeEncasedInRegion()
{
StringBuilder header = new StringBuilder();
header.Append("#region Header");
header.Append("\n// Content\n");
header.Append("#endregion");
IList <StatementBase> statements = new List <StatementBase>();
statements.Add(StatementCreator.CreateRegionStartStatement("#region Header"));
statements.Add(StatementCreator.CreateLineCommentStatement("\n// Content\n"));
statements.Add(StatementCreator.CreateRegionEndStatement("#endregion"));
FileBlock block = new FileBlock(statements);
FileBlockStartsWithHeaderRule rule = new FileBlockStartsWithHeaderRule(header.ToString());
Assert.IsTrue(rule.IsValidFor(block));
}
public void ValidatesShouldReturnTrueForFileBlock()
{
StringBuilder header = new StringBuilder();
header.Append("// A file header\n");
header.Append("// Containing information\n");
header.Append("// And copyrights");
IList <StatementBase> statements = new List <StatementBase>();
statements.Add(StatementCreator.CreateLineCommentStatement("// A file header\n"));
statements.Add(StatementCreator.CreateLineCommentStatement("// Containing information\n"));
statements.Add(StatementCreator.CreateLineCommentStatement("// And copyrights\n"));
FileBlock block = new FileBlock(statements);
FileBlockStartsWithHeaderRule rule = new FileBlockStartsWithHeaderRule(header.ToString());
Assert.IsTrue(rule.IsValidFor(block));
}
public void ParserShouldCallSBlockFactoryWhenParsingStatements()
{
IList <StatementBase> input = new List <StatementBase>();
input.Add(StatementCreator.CreateMemberStatement("_someString"));
IBlockFactory factory = Mocker.StrictMock <IBlockFactory>();
Expect.Call(factory.Create(input)).Return(new [] { new BlockBaseImpl(input) }).Repeat.Once();
StubBlockFactoryProvider provider = new StubBlockFactoryProvider(factory);
CalidusBlockParser parser = new CalidusBlockParser(provider);
Mocker.ReplayAll();
parser.Parse(input);
Mocker.VerifyAll();
}
public void FactoryShouldCreateStatementFromThisFollowedBySquareBracketInClass()
{
Expect.Call(_context.Parents).Return(new[] { new StatementParent(StatementCreator.CreateClassStatement(), StatementCreator.CreateOpenBlockStatement()) }).Repeat.Once();
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <PublicModifierToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("String"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <ThisToken>());
input.Add(TokenCreator.Create <OpenSquareBracketToken>());
input.Add(TokenCreator.Create <IntToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("index"));
input.Add(TokenCreator.Create <CloseSquareBracketToken>());
Mocker.ReplayAll();
Assert.IsTrue(_factory.CanCreateStatementFrom(input, _context));
Mocker.VerifyAll();
}
public void ShouldProduceAStatement()
{
var customer = new Customer("Bob");
customer.AddRental(new Rental(new RegularMovie("Pulp Fiction"), 2));
customer.AddRental(new Rental(new ChildrensMovie("Lilo & Stitch"), 3));
customer.AddRental(new Rental(new RegularMovie("Gladiator"), 6));
customer.AddRental(new Rental(new NewReleaseMovie("Magic Mike"), 4));
var statementCreator = new StatementCreator();
var bobsStatement = statementCreator.CreateStatement(customer);
const string expectedStatement = "Rental Record for Bob\n" +
"\tPulp Fiction\t2\n" +
"\tLilo & Stitch\t1.5\n" +
"\tGladiator\t8\n" +
"\tMagic Mike\t12\n" +
"You owed 23.5\n" +
"You earned 5 frequent renter points\n";
Assert.AreEqual(expectedStatement, bobsStatement);
}
public void ExplicitAccessModifierRuleShouldValidateMembers()
{
Assert.IsTrue(_rule.Validates(StatementCreator.CreateMemberStatement("test")));
}
public void RuleShouldReturnInvalidForStatementsThatDoNotMatchThePattern()
{
MemberNameMatchesPatternRule rule = new MemberNameMatchesPatternRule(new Regex("^_[a-z]+"), false);
Assert.IsFalse(rule.IsValidFor(StatementCreator.CreateMemberStatement("ATest")));
}
public void RuleShouldValidateStatements()
{
MemberNameMatchesPatternRule rule = new MemberNameMatchesPatternRule(new Regex(""), false);
Assert.IsTrue(rule.Validates(StatementCreator.CreateMemberStatement("member")));
}
public void ExplicitAccessModifierRuleShouldValidateMethods()
{
Assert.IsTrue(_rule.Validates(StatementCreator.CreateMethodStatement()));
}
public override void SetUp()
{
base.SetUp();
_statement = StatementCreator.CreateMemberStatement("member");
}
public void RuleShouldBeValidForElementWithExplicitAccessModifier()
{
Assert.IsTrue(_rule.IsValidFor(StatementCreator.CreateClassStatement()));
}
