public void NumericLiteral_DecimalStartingWithPeriod()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens(".545878 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLNumericLiteral(0, ".545878"),
                new TSQLWhitespace(7, " ")
            },
                tokens);
        }
        public void NumericLiteral_ComplicatedExponential()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("54.0e-4 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLNumericLiteral(0, "54.0e-4"),
                new TSQLWhitespace(7, " ")
            },
                tokens);
        }
Esempio n. 3
0
        public void Operator_NotEqualExclamation()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("!= ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLOperator(0, "!="),
                new TSQLWhitespace(2, " ")
            },
                tokens);
        }
Esempio n. 4
0
        public void StringLiteralToken_DoubleQuote()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("\"name\" ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLStringLiteral(0, "\"name\""),
                new TSQLWhitespace(6, " ")
            },
                tokens);
        }
Esempio n. 5
0
        public void BinaryToken_SimpleBinaryLiteral()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("0x69048AEFDD010E ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLBinaryLiteral(0, "0x69048AEFDD010E"),
                new TSQLWhitespace(16, " ")
            },
                tokens);
        }
Esempio n. 6
0
        public void MultilineCommentToken_SpanLines()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("/* blah\r\nblah */ ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMultilineComment(0, "/* blah\r\nblah */"),
                new TSQLWhitespace(16, " ")
            },
                tokens);
        }
Esempio n. 7
0
        public void MoneyLiteral_ForeignNegative()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("£-.1 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMoneyLiteral(0, "£-.1"),
                new TSQLWhitespace(4, " ")
            },
                tokens);
        }
Esempio n. 8
0
        public void BinaryToken_EmptyBinaryLiteralCaseInsensitive()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("0X ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLBinaryLiteral(0, "0X"),
                new TSQLWhitespace(2, " ")
            },
                tokens);
        }
Esempio n. 9
0
        public void IdentifierToken_EscapedBracketedIdentifier2()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("[a]]a] ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIdentifier(0, "[a]]a]"),
                new TSQLWhitespace(6, " ")
            },
                tokens);
        }
Esempio n. 10
0
        public void SingleLineCommentToken_LineFeed()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("--blah\n", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLSingleLineComment(0, "--blah"),
                new TSQLWhitespace(6, "\n")
            },
                tokens);
        }
Esempio n. 11
0
        public void BinaryToken_BinaryLiteralEndWithLetter()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("0x69048AEFDD010EJ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLBinaryLiteral(0, "0x69048AEFDD010E"),
                new TSQLIdentifier(16, "J")
            },
                tokens);
        }
Esempio n. 12
0
        public void IdentifierToken_SimpleIdentifier()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("a ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIdentifier(0, "a"),
                new TSQLWhitespace(1, " ")
            },
                tokens);
        }
Esempio n. 13
0
        public void IncompleteToken_Comment()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("/* something", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIncompleteCommentToken(0, "/* something")
            },
                tokens);
            Assert.IsFalse(tokens[0].IsComplete);
        }
Esempio n. 14
0
        public void IdentifierToken_QuotedUnicodeIdentifier()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("N\"name\" ", useQuotedIdentifiers: true, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIdentifier(0, "N\"name\""),
                new TSQLWhitespace(7, " ")
            },
                tokens);
        }
Esempio n. 15
0
        public void IncompleteToken_StringLiteral()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("'", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIncompleteStringToken(0, "'")
            },
                tokens);
            Assert.IsFalse(tokens[0].IsComplete);
        }
Esempio n. 16
0
        public void IncompleteToken_Identifier()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("[dbo", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIncompleteIdentifierToken(0, "[dbo")
            },
                tokens);
            Assert.IsFalse(tokens[0].IsComplete);
        }
Esempio n. 17
0
        public void MoneyLiteral_StartingWithPeriod()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("$.1 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMoneyLiteral(0, "$.1"),
                new TSQLWhitespace(3, " ")
            },
                tokens);
        }
Esempio n. 18
0
        public void StringLiteralToken_SingleQuoteUnicode()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("N'name' ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLStringLiteral(0, "N'name'"),
                new TSQLWhitespace(7, " ")
            },
                tokens);
        }
Esempio n. 19
0
        public void KeywordToken_SimpleKeywordLowercase()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("go ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLKeyword(0, "go"),
                new TSQLWhitespace(2, " ")
            },
                tokens);
        }
Esempio n. 20
0
        public void MultilineCommentToken_RequireFullEnding()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("/*/ blah */ ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMultilineComment(0, "/*/ blah */"),
                new TSQLWhitespace(11, " ")
            },
                tokens);
        }
Esempio n. 21
0
        public void Operator_LessThan()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("< ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLOperator(0, "<"),
                new TSQLWhitespace(1, " ")
            },
                tokens);
        }
Esempio n. 22
0
        public void CharacterToken_Period()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens(". ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLCharacter(0, "."),
                new TSQLWhitespace(1, " ")
            },
                tokens);
        }
Esempio n. 23
0
        public void SystemVariableToken_BogusVariable()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("@@BOGUS ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLVariable(0, "@@BOGUS"),
                new TSQLWhitespace(7, " ")
            },
                tokens);
            Assert.IsFalse(tokens[0] is TSQLSystemVariable);
        }
Esempio n. 24
0
        public void BinaryToken_EmbeddedLineContinuation()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("0xabc\\\r\ndef ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLBinaryLiteral(0, "0xabc\\\r\ndef"),
                new TSQLWhitespace(11, " ")
            },
                tokens);
            Assert.AreEqual("0xABCDEF", tokens[0].AsBinaryLiteral.Value);
        }
Esempio n. 25
0
        public void StringLiteralToken_MultiLine()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("'a\r\nb' ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLStringLiteral(0, "'a\r\nb'"),
                new TSQLWhitespace(6, " ")
            },
                tokens);
            Assert.AreEqual("a\r\nb", tokens[0].AsStringLiteral.Value);
        }
Esempio n. 26
0
        public void IdentifierToken_BracketedMultiLine()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("[a\r\nb] ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIdentifier(0, "[a\r\nb]"),
                new TSQLWhitespace(6, " ")
            },
                tokens);
            Assert.AreEqual("a\r\nb", tokens[0].AsIdentifier.Name);
        }
Esempio n. 27
0
        public void SystemIdentifierToken_SimpleIdentifier()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("SYSTEM_USER ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLSystemIdentifier(0, "SYSTEM_USER"),
                new TSQLWhitespace(11, " ")
            },
                tokens);
            Assert.AreEqual(TSQLIdentifiers.SYSTEM_USER, tokens[0].AsSystemIdentifier.Identifier);
        }
Esempio n. 28
0
        public void IdentifierToken_OnlyN()
        {
            // unicode string literals are a special case that start with N
            // test here to make sure it gets parsed as an identifier token
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("N ", useQuotedIdentifiers: false, includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLIdentifier(0, "N"),
                new TSQLWhitespace(1, " ")
            },
                tokens);
        }
Esempio n. 29
0
        public void MoneyLiteral_Subtraction()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("$2-$1 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMoneyLiteral(0, "$2"),
                new TSQLOperator(2, "-"),
                new TSQLMoneyLiteral(3, "$1"),
                new TSQLWhitespace(5, " ")
            },
                tokens);
        }
Esempio n. 30
0
        public void MoneyLiteral_Negative()
        {
            List <TSQLToken> tokens = TSQLTokenizer.ParseTokens("$-.1 ", includeWhitespace: true);

            TokenComparisons.CompareTokenLists(
                new List <TSQLToken>()
            {
                new TSQLMoneyLiteral(0, "$-.1"),
                new TSQLWhitespace(4, " ")
            },
                tokens);

            Assert.AreEqual(-0.1m, tokens[0].AsMoneyLiteral.Value);
        }