コード例 #1
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildBalancingGroupNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.GroupDirectiveStart, "?", 1),
                new Token(TokenType.NamedIdentifierStartOrLookBehindMarker, "<", 2),
                new Token(TokenType.Literal, "foo", 3),
                new Token(TokenType.BalancingGroupNamedIdentifierSeparator, "-", 6),
                new Token(TokenType.Literal, "bar", 7),
                new Token(TokenType.NamedIdentifierEnd, ">", 10),
                new Token(TokenType.Literal, "baz", 11),
                new Token(TokenType.GroupEnd, ")", 14)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("(?<foo-bar>baz)", 0,
                        new LiteralNode("baz", 11))
                    { NamedIdentifier = "foo", BalancingGroupIdentifier = "bar" }
                },
                nodes.Children.ToArray()
            );
        }
コード例 #2
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildMaxParametizedQuantifierNodeForSingleCharacterLiteral()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "a", 0),
                new Token(TokenType.ParametizedQuantifierStart, "{", 1),
                new Token(TokenType.ParametizedQuantifierRangeSeparator, ",", 2),
                new Token(TokenType.Number, "3", 3),
                new Token(TokenType.ParametizedQuantifierEnd, "}", 4)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new QuantifierNode("a{,3}", 0,
                        null, 3,
                        new LiteralNode("a", 0))
                },
                nodes.Children.ToArray()
            );
        }
コード例 #3
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildMinMaxParametizedQuantifierNodeAroundLastCharacterOfMultiCharacterLiteral()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "abc", 0),
                new Token(TokenType.ParametizedQuantifierStart, "{", 3),
                new Token(TokenType.Number, "3", 4),
                new Token(TokenType.ParametizedQuantifierRangeSeparator, ",", 5),
                new Token(TokenType.Number, "16", 6),
                new Token(TokenType.ParametizedQuantifierEnd, "}", 8)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new Node[]
                {
                    new LiteralNode("ab", 0),
                    new QuantifierNode("c{3,16}", 2,
                        3, 16,
                        new LiteralNode("c", 2))
                },
                nodes.Children.ToArray()
            );
        }
コード例 #4
0
        public void TreeBuilder_BuildExpressionNode_ShouldConvertParseFailureToken()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.ParseFailure, "x", 0)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new ParseFailureNode("x", 0, "unrecognised token")
                },
                nodes.Children.ToArray()
            );
        }
コード例 #5
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildLiteralTokenIntoLiteralNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "abc", 0)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new LiteralNode("abc", 0)
                },
                nodes.Children.ToArray()
            );
        }
コード例 #6
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildEmptyGroupNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.GroupEnd, ")", 1),
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("()", 0)
                },
                nodes.Children.ToArray()
            );
        }
コード例 #7
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildCharacterEscapeIntoEscapeCharacterNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.CharacterEscapeMarker, @"\", 0),
                new Token(TokenType.CharacterEscapeData, ")", 1)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new EscapedCharacterNode(@"\)", 0, ")")
                },
                nodes.Children.ToArray()
            );
        }
コード例 #8
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildNonDigitsCharacterClassNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.CharacterEscapeMarker, @"\", 10),
                new Token(TokenType.CharacterEscapeData, "D", 11)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new CharacterClassNode(@"\D", 10, CharacterClass.NonDigits)
                },
                nodes.Children.ToArray()
            );
        }
コード例 #9
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildCapturingGroupNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.Literal, "abc", 1),
                new Token(TokenType.GroupEnd, ")", 4),
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("(abc)", 0,
                        new LiteralNode("abc", 1))
                    { GroupMode = GroupMode.CapturingGroup }
                },
                nodes.Children.ToArray()
            );
        }
コード例 #10
0
        public void TreeBuilder_Build_ShouldAssignIds()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "1", 0),    // 1
                new Token(TokenType.Literal, "2", 1),    // 2
                new Token(TokenType.Literal, "3", 2),    // 3
            };

            // Act
            var nodes = new TreeBuilder().Build(tokens);

            // Assert
            CollectionAssert.AreEqual(new Node[]
                {
                    new LiteralNode("1", 0) { NodeId = 1 },
                    new LiteralNode("2", 1) { NodeId = 2 },
                    new LiteralNode("3", 2) { NodeId = 3 },
                },
                nodes.Children.ToArray()
            );
        }
コード例 #11
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildNestedGroupNodeWithLiteralContent()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.Literal, "abc", 1),
                new Token(TokenType.GroupStart, "(", 4),
                new Token(TokenType.Literal, "def", 5),
                new Token(TokenType.GroupEnd, ")", 8),
                new Token(TokenType.Literal, "ghi", 9),
                new Token(TokenType.GroupEnd, ")", 12),
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("(abc(def)ghi)", 0,
                        new LiteralNode("abc", 1),
                        new GroupNode("(def)", 4,
                            new LiteralNode("def", 5)),
                        new LiteralNode("ghi", 9))
                },
                nodes.Children.ToArray()
            );
        }
コード例 #12
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildParseFailureNodeForUnclosedGroup()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new ParseFailureNode("(", 0, "group is never closed")
                },
                nodes.Children.ToArray()
            );
        }
コード例 #13
0
        public void TreeBuilder_BuildExpressionNode_ShouldHandleMalformedParametizedQuantifierTokensAsLiteral()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "a", 0),
                new Token(TokenType.ParametizedQuantifierStart, "{", 1),
                new Token(TokenType.Number, "8", 2),
                new Token(TokenType.ParametizedQuantifierRangeSeparator, ",", 3),
                new Token(TokenType.ParametizedQuantifierRangeSeparator, ",", 4),
                new Token(TokenType.ParametizedQuantifierEnd, "}", 5)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new LiteralNode("a", 0),
                    new LiteralNode("{8,,}", 1)
                },
                nodes.Children.ToArray()
            );
        }
コード例 #14
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildZeroOrOneQuantifierNodeForSingleCharacterLiteral()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "a", 0),
                new Token(TokenType.Quantifier, "?", 1)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new QuantifierNode("a?", 0,
                        0, 1,
                        new LiteralNode("a", 0))
                },
                nodes.Children.ToArray()
            );
        }
コード例 #15
0
        public void TreeBuilder_BuildExpressionNode_ShouldBuildQuantifierNodeAroundLastCharacterOfMultiCharacterLiteral()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.Literal, "abc", 0),
                new Token(TokenType.Quantifier, "*", 1)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new Node[]
                {
                    new LiteralNode("ab", 0),
                    new QuantifierNode("c*", 2,
                        0, null,
                        new LiteralNode("c", 2))
                },
                nodes.Children.ToArray()
            );
        }
コード例 #16
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildPositiveLookBehindGroupNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.GroupDirectiveStart, "?", 1),
                new Token(TokenType.NamedIdentifierStartOrLookBehindMarker, "<", 2),
                new Token(TokenType.PositiveLookBehindMarker, "=", 3),
                new Token(TokenType.Literal, "abc", 4),
                new Token(TokenType.GroupEnd, ")", 7),
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("(?<=abc)", 0,
                        new LiteralNode("abc", 4))
                    { GroupMode = GroupMode.PositiveLookBehind }
                },
                nodes.Children.ToArray()
            );
        }
コード例 #17
0
        ActionResult AnalyzeVerbose(string expression)
        {
            var stopwatch = new Stopwatch();
            stopwatch.Start();

            var tokens = Tokenizer.Tokenize(expression);
            var rootNode = new TreeBuilder().Build(tokens);

            stopwatch.Stop();

            ViewData["TimeTaken"] = stopwatch.Elapsed;

            ViewData["Tokens"] = tokens;

            ViewData["ExpressionMarkup"] = RenderExpressionAsHtml(rootNode);
            ViewData["AllNodes"] = FlattenNodes(rootNode.Children);
            ViewData["NodesMarkup"] = RenderNodesAsHtml(rootNode.Children);

            return View(Views.Verbose);
        }
コード例 #18
0
        public void TreeBuilder_BuildExpressionNode_ShouldConvertUnexpectedTokenToParseFailureNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupEnd, ")", 0)
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new ParseFailureNode(")", 0, "unexpected token")
                },
                nodes.Children.ToArray()
            );
        }
コード例 #19
0
        public void TreeBuilding_BuildExpressionNode_ShouldBuildNegativeLookAheadGroupNode()
        {
            // Arrange
            var tokens = new[]
            {
                new Token(TokenType.GroupStart, "(", 0),
                new Token(TokenType.GroupDirectiveStart, "?", 1),
                new Token(TokenType.NegativeLookAheadMarker, "!", 2),
                new Token(TokenType.Literal, "abc", 3),
                new Token(TokenType.GroupEnd, ")", 6),
            };

            // Act
            var nodes = new TreeBuilder().BuildExpressionNode(tokens);

            // Assert
            CollectionAssert.AreEqual(new[]
                {
                    new GroupNode("(?!abc)", 0,
                        new LiteralNode("abc", 3))
                    { GroupMode = GroupMode.NegativeLookAhead }
                },
                nodes.Children.ToArray()
            );
        }