public void GetDescendantsShouldReturnAllDescendants() { // Arrange // a+bc* var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var charNodeC = new CharacterNode('c'); var quantifierPlus = new QuantifierPlusNode(charNodeA); var quantifierStar = new QuantifierStarNode(charNodeC); var grandchildren = new List <RegexNode> { quantifierPlus, charNodeB, quantifierStar }; var concatenationNode = new ConcatenationNode(grandchildren); var target = new TestRegexNode(concatenationNode); // Act IEnumerable <RegexNode> result = target.GetDescendantNodes(); // Assert result.Count().ShouldBe(6); result.First().ShouldBe(charNodeA); result.ElementAt(1).ShouldBe(quantifierPlus); result.ElementAt(2).ShouldBe(charNodeB); result.ElementAt(3).ShouldBe(charNodeC); result.ElementAt(4).ShouldBe(quantifierStar); result.Last().ShouldBe(concatenationNode); }
public void ReplaceNodeShouldAddOldNodesPrefixAsFirstPrefixIfNewNodeAlreadyHasMultiplePrefixes() { // Arrange var oldNodePrefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = oldNodePrefix }; var newNodeFirstPrefix = new CommentGroupNode("This is the first prefix of the new node."); var newNodeSecondPrefix = new CommentGroupNode("This is the second prefix of the new node.") { Prefix = newNodeFirstPrefix }; var newNode = new TestRegexNode() { Prefix = newNodeSecondPrefix }; var target = new ConcatenationNode(oldNode); // Act RegexNode result = target.ReplaceNode(oldNode, newNode); // Assert var childNode = result.ChildNodes.ShouldHaveSingleItem(); childNode.Prefix.Comment.ShouldBe(newNode.Prefix.Comment); childNode.Prefix.Prefix.ShouldNotBeNull(); childNode.Prefix.Prefix.Comment.ShouldBe(newNode.Prefix.Prefix.Comment); childNode.Prefix.Prefix.Prefix.ShouldNotBeNull(); childNode.Prefix.Prefix.Prefix.Comment.ShouldBe(oldNodePrefix.Comment); }
public void RemoveNodeShouldAddOldNodesPrefixAsPrefixToNextNodesPrefixIfNextNodeAlreadyHasPrefix() { // Arrange var oldNodePrefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = oldNodePrefix }; var nextNodePrefix = new CommentGroupNode("This is the prefix of the next node."); var nextNode = new TestRegexNode() { Prefix = nextNodePrefix }; var target = new ConcatenationNode(new List <RegexNode> { oldNode, nextNode }); // Act RegexNode result = target.RemoveNode(oldNode); // Assert var remainingNode = result.ChildNodes.ShouldHaveSingleItem(); remainingNode.Prefix.Comment.ShouldBe(nextNode.Prefix.Comment); remainingNode.Prefix.Prefix.ShouldNotBeNull(); remainingNode.Prefix.Prefix.Comment.ShouldBe(oldNodePrefix.Comment); }
public void EmptyConstructorShouldReturnNewRegexNodeWithNoChildNodes() { // Arrange var target = new TestRegexNode(); // Assert target.ChildNodes.ShouldBeEmpty(); }
public void GetDescendantsOnNodeWithNoChildrenShouldReturnEmptyIEnumerable() { // Arrange var target = new TestRegexNode(); // Act IEnumerable <RegexNode> result = target.GetDescendantNodes(); // Assert result.ShouldBeEmpty(); }
public void GetSpanShouldReturnTupleWithStart0AndLenghtEqualToToStringLength() { // Arrange var target = new TestRegexNode(); var targetLength = target.ToString().Length; // Act var(Start, Length) = target.GetSpan(); // Assert Start.ShouldBe(0); Length.ShouldBe(targetLength); }
public void RemoveNodeShouldNotAddEmptyNodeWithIfOldNodeHasNoPrefix() { // Arrange var oldNode = new TestRegexNode(); var target = new ConcatenationNode(new List <RegexNode> { oldNode }); // Act RegexNode result = target.RemoveNode(oldNode); // Assert result.ChildNodes.ShouldBeEmpty(); }
public void AddNodeShouldCopyNodeAndAddNewRegexNode() { // Arrange var target = new TestRegexNode(new List <RegexNode> { new CharacterNode('a'), new CharacterNode('b') }); var newNode = new CharacterNode('c'); // Act RegexNode result = target.AddNode(newNode); // Assert result.ChildNodes.Count().ShouldBe(3); result.ChildNodes.Last().ShouldBe(newNode); }
public void ConstructorWithChildNodesShouldReturnNewRegexNodeWithChildNodes() { // Arrange var childNodes = new List <RegexNode> { new CharacterNode('a'), new CharacterNode('b') }; // Act var target = new TestRegexNode(childNodes); // Assert target.ChildNodes.Count().ShouldBe(2); target.ChildNodes.First().ToString().ShouldBe("a"); target.ChildNodes.ElementAt(1).ToString().ShouldBe("b"); }
public void AddNodeResultShouldNotHaveReferenceToOriginalPrefix() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var target = new TestRegexNode { Prefix = prefix }; var newNode = new TestRegexNode(); // Act RegexNode result = target.AddNode(newNode); // Assert result.Prefix.ShouldNotBe(target.Prefix); }
public void AddNodeShouldCopyPrefix() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var target = new TestRegexNode { Prefix = prefix }; var newNode = new TestRegexNode(); // Act RegexNode result = target.AddNode(newNode); // Assert result.Prefix.ToString().ShouldBe(target.Prefix.ToString()); }
public void RemoveNodeShouldHaveNoReferencesToTheOriginalTreeNodes() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var childNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(childNodes); // Act RegexNode result = target.RemoveNode(charNodeA); // Assert result.ShouldNotBe(target); result.ChildNodes.ShouldNotContain(charNodeA); result.ChildNodes.ShouldNotContain(charNodeB); }
public void RemoveNodeShouldCopyNodeAndRemoveOldNode() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var childNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(childNodes); // Act RegexNode result = target.RemoveNode(charNodeA); // Assert var childNode = result.ChildNodes.ShouldHaveSingleItem(); childNode.ToString().ShouldBe("b"); }
public void ReplaceNodeShouldCopyNodeAndReplaceOldNodeWithNewNode() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var childNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(childNodes); var newNode = new CharacterNode('c'); // Act RegexNode result = target.ReplaceNode(charNodeA, newNode); // Assert result.ChildNodes.Count().ShouldBe(2); result.ChildNodes.First().ShouldBe(newNode); }
public void GetSpanShouldReturnTupleWithStartEqualToPrefixLengthAndEqualToToStringLengthMinusPrefixLength() { // Arrange var commentGroup = new CommentGroupNode("X"); var target = new TestRegexNode() { Prefix = commentGroup }; var prefixLength = commentGroup.ToString().Length; var targetLength = target.ToString().Length; // Act var(Start, Length) = target.GetSpan(); // Assert Start.ShouldBe(prefixLength); Length.ShouldBe(targetLength - prefixLength); }
public void RemoveNodeShouldNotChangeOriginalNextNodeWhenMovingPrefix() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = prefix }; var nextNode = new TestRegexNode(); var target = new ConcatenationNode(new List <RegexNode> { oldNode, nextNode }); // Act _ = target.RemoveNode(oldNode); // Assert nextNode.Prefix.ShouldBeNull(); }
public void AddNodeShouldNotReturnRootNodeIfReturnRootIsFalse() { // Arrange var targetChildNodes = new List <RegexNode> { new CharacterNode('a'), new CharacterNode('b') }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); var newNode = new CharacterNode('c'); // Act RegexNode result = target.AddNode(newNode, false); // Assert result.ChildNodes.Count().ShouldBe(3); result.ChildNodes.Last().ShouldBe(newNode); }
public void ReplaceNodeShouldMoveOldNodesPrefixToNewNode() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = prefix }; var newNode = new TestRegexNode(); var target = new ConcatenationNode(oldNode); // Act RegexNode result = target.ReplaceNode(oldNode, newNode); // Assert var childNode = result.ChildNodes.ShouldHaveSingleItem(); childNode.Prefix.ShouldNotBeNull(); childNode.Prefix.Comment.ShouldBe(prefix.Comment); }
public void AddNodeShouldCopyDescendants() { // Arrange var grandChildConcatNode = new ConcatenationNode(new List <RegexNode> { new CharacterNode('d'), new CharacterNode('e') }); var childConcatNode = new ConcatenationNode(new List <RegexNode> { grandChildConcatNode, new CharacterNode('a'), new CharacterNode('b') }); var target = new TestRegexNode(childConcatNode); var newNode = new CharacterNode('c'); // Act RegexNode result = target.AddNode(newNode); // Assert result.ChildNodes.Count().ShouldBe(2); result.ChildNodes.First().ChildNodes.Count().ShouldBe(3); result.ChildNodes.First().ChildNodes.First().ChildNodes.Count().ShouldBe(2); }
public void RemoveNodeShouldCopyRootsPrefix() { // Arrange var prefix2 = new CommentGroupNode("This is the prefix's prefix."); var prefix = new CommentGroupNode("This is a prefix.") { Prefix = prefix2 }; var oldNode = new TestRegexNode(); var target = new TestRegexNode(oldNode) { Prefix = prefix }; // Act RegexNode result = target.RemoveNode(oldNode); // Assert result.Prefix.ToString().ShouldBe(target.Prefix.ToString()); }
public void ReplaceNodeShouldNotReturnRootNodeIfReturnRootIsFalse() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var targetChildNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); var newNode = new CharacterNode('c'); // Act RegexNode result = target.ReplaceNode(charNodeA, newNode, false); // Assert result.ChildNodes.Count().ShouldBe(2); result.ChildNodes.First().ShouldBe(newNode); }
public void RemoveNodeShouldAddEmptyNodeWithOldNodesPrefixIfThereAreNoNextNodes() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = prefix }; var target = new ConcatenationNode(new List <RegexNode> { oldNode }); // Act RegexNode result = target.RemoveNode(oldNode); // Assert var emptyNode = result.ChildNodes.ShouldHaveSingleItem().ShouldBeOfType <EmptyNode>(); emptyNode.Prefix.ShouldNotBeNull(); emptyNode.Prefix.Comment.ShouldBe(prefix.Comment); }
public void RemoveNodeShouldNotReturnRootNodeIfReturnRootIsFalse() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var targetChildNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); // Act RegexNode result = target.RemoveNode(charNodeA, false); // Assert var childNode = result.ChildNodes.ShouldHaveSingleItem(); childNode.ToString().ShouldBe("b"); }
public void AddNodeShouldReturnRootNode() { // Arrange var targetChildNodes = new List <RegexNode> { new CharacterNode('a'), new CharacterNode('b') }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); var newNode = new CharacterNode('c'); // Act RegexNode result = target.AddNode(newNode); // Assert var copiedTargetParent = result.ChildNodes.ShouldHaveSingleItem(); var modifiedTarget = copiedTargetParent.ChildNodes.ShouldHaveSingleItem(); modifiedTarget.ChildNodes.Count().ShouldBe(3); modifiedTarget.ChildNodes.Last().ShouldBe(newNode); }
public void RemoveNodeShouldMoveOldNodesPrefixToNextNodeInTheCopy() { // Arrange var prefix = new CommentGroupNode("This is a prefix."); var oldNode = new TestRegexNode() { Prefix = prefix }; var nextNode = new TestRegexNode(); var target = new ConcatenationNode(new List <RegexNode> { oldNode, nextNode }); // Act RegexNode result = target.RemoveNode(oldNode); // Assert var remainingNode = result.ChildNodes.ShouldHaveSingleItem(); remainingNode.Prefix.ShouldNotBeNull(); remainingNode.Prefix.Comment.ShouldBe(prefix.Comment); }
public void RemoveNodeShouldReturnRootNode() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var targetChildNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); // Act RegexNode result = target.RemoveNode(charNodeA); // Assert var copiedTargetParentNode = result.ChildNodes.ShouldHaveSingleItem(); var modifiedNode = copiedTargetParentNode.ChildNodes.ShouldHaveSingleItem(); modifiedNode.ChildNodes.ShouldHaveSingleItem(); modifiedNode.ChildNodes.First().ToString().ShouldBe("b"); }
public void ReplaceNodeShouldReturnRootNode() { // Arrange var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var targetChildNodes = new List <RegexNode> { charNodeA, charNodeB }; var target = new TestRegexNode(targetChildNodes); var targetParent = new TestRegexNode(target); _ = new TestRegexNode(targetParent); var newNode = new CharacterNode('c'); // Act RegexNode result = target.ReplaceNode(charNodeA, newNode); // Assert var copiedTargetParent = result.ChildNodes.ShouldHaveSingleItem(); var modifierTarget = copiedTargetParent.ChildNodes.ShouldHaveSingleItem(); modifierTarget.ChildNodes.Count().ShouldBe(2); modifierTarget.ChildNodes.First().ShouldBe(newNode); }