public void InvalidExpressionsThrow(string content)
        {
            // Arrange
            using (var wrapper = new MapLexerWrapper(content))
            {
                Action act = () => parser.Parse(wrapper.Lexer, context);

                // Act and assert
                act.Should().Throw <ParserException>();
            }
        }
        public void PrefixIsSet(string content)
        {
            // Arrange
            using (var context = new MapLexerWrapper(content))
            {
                // Act
                var ident = CompoundIdentifier.Parse(context.Lexer);

                // Assert
                ident.Prefix.Should().Be("pre");
            }
        }
        public void CanParseThemAll(string content)
        {
            // Arrange
            using (var context = new MapLexerWrapper(content))
            {
                // Act
                var ident = CompoundIdentifier.Parse(context.Lexer);

                // Assert
                ident.ToString().Should().Be(content);
            }
        }
        public void CanParseMultipleArguments(string content, int argumentCount)
        {
            // Arrange
            using (var wrapper = new MapLexerWrapper(content))
            {
                // Act
                var expression = parser.Parse(wrapper.Lexer, context);

                // Assert
                expression.FunctionName.Should().Be("concat");

                expression.Arguments.Should().HaveCount(argumentCount);
            }
        }
        public void CanParseSingleArgumentFunctions(string content, string functionName)
        {
            // Arrange
            using (var wrapper = new MapLexerWrapper(content))
            {
                // Act
                var expression = parser.Parse(wrapper.Lexer, context);

                // Assert
                expression.FunctionName.Should().Be(functionName);

                // TODO - check arguments
            }
        }
        public void CanParseIdentifier(string content)
        {
            // Arrange
            using (var wrapper = new MapLexerWrapper(content))
            {
                // Act
                var expression = parser.Parse(wrapper.Lexer, context);

                // Assert
                expression.FunctionName.Should().BeNull();
                expression.Arguments.Should().HaveCount(1);

                var arg = expression.Arguments[0];

                arg.Attribute.XPath.Should().Be("Person/Name");
            }
        }
        public void PartsAreSet(string content)
        {
            // Arrange
            using (var context = new MapLexerWrapper(content))
            {
                // Act
                var ident = CompoundIdentifier.Parse(context.Lexer);

                // Assert
                if (!content.Contains(":"))
                {
                    ident.Prefix.Should().BeNull();
                }

                ident.Parts.Should().BeEquivalentTo("name");
            }
        }