public void GroupNode_Description_ShouldReturnBalancingGroup()
{
var node = new GroupNode("(abc)", 0)
{
BalancingGroupIdentifier = "foo",
NamedIdentifier = "bar"
};
Assert.AreEqual("balancing group 'foo', captured in 'bar'", node.Description);
}
public static Node BuildGroupNode(Token startToken, TreeBuilderState state)
{
var contentsTokens = new List<Token>();
Token endToken = null;
var nestedGroupDepth = 0;
while (state.ProcessingState.Tokens.Any())
{
var token = state.ProcessingState.Tokens.Dequeue();
switch (token.Type)
{
case TokenType.GroupStart:
nestedGroupDepth++;
break;
case TokenType.GroupEnd:
nestedGroupDepth--;
break;
}
if (nestedGroupDepth >= 0)
{
contentsTokens.Add(token);
}
else
{
endToken = token;
break;
}
}
if (endToken == null)
return new ParseFailureNode(startToken, "group is never closed");
var combinedData = Token.GetData(startToken, contentsTokens, endToken);
var groupNode = new GroupNode(
combinedData,
startToken.StartIndex
);
// Queue the group contents for processing
state.ProcessingQueue.Enqueue(new KeyValuePair<Node, IEnumerable<Token>>(
groupNode,
contentsTokens
));
return groupNode;
}
static void ProcessNamedGroupDirective(GroupNode group, IEnumerable<Token> tokens)
{
var identifierTokens = tokens
.Skip(1)
.Take(tokens.Count() - 2);
var identifier = Token.GetData(identifierTokens);
group.NamedIdentifier = identifier;
}
static void ProcessBalancingGroupDirective(GroupNode group, IEnumerable<Token> tokens)
{
var identifierTokens = tokens
.Skip(1)
.TakeWhile(t => t.Type == TokenType.Literal);
var namedIdentifier = Token.GetData(identifierTokens);
group.NamedIdentifier = namedIdentifier;
var balancingGroupTokens = tokens
.Skip(1) // ?
.Skip(identifierTokens.Count())
.Skip(1) // -
.TakeWhile(t => t.Type == TokenType.Literal);
var balancingGroupIdentifier = Token.GetData(balancingGroupTokens);
group.BalancingGroupIdentifier = balancingGroupIdentifier;
}
public void GroupNode_Equals_ShouldReturnTrueWithDefaultConstructor()
{
var lhs = new GroupNode("(abc)", 0);
var rhs = new GroupNode("(abc)", 0);
Assert.IsTrue(lhs.Equals(rhs));
}
public void GroupNode_Equals_ShouldReturnFalseWhenNamedIdentifierDiffers()
{
var lhs = new GroupNode("(abc)", 0) { NamedIdentifier = "abc" };
var rhs = new GroupNode("(abc)", 0) { NamedIdentifier = "def" };
Assert.IsFalse(lhs.Equals(rhs));
}
public void GroupNode_Equals_ShouldReturnFalseWhenGroupModeDiffers()
{
var lhs = new GroupNode("(abc)", 0) { GroupMode = GroupMode.CapturingGroup };
var rhs = new GroupNode("(abc)", 0) { GroupMode = GroupMode.NonCapturingGroup };
Assert.IsFalse(lhs.Equals(rhs));
}
public void GroupNode_Description_ShouldReturnNamedGroupWithIdentifier()
{
var node = new GroupNode("(abc)", 0) { NamedIdentifier = "foo" };
Assert.AreEqual("named group 'foo'", node.Description);
}
public void GroupNode_Description_ShouldReturnGroupForSimpleCaptureGroup()
{
var node = new GroupNode("(abc)", 0);
Assert.AreEqual("group", node.Description);
}
