Place regression tests beside related syntax cases

Author: LucaCappelletti94

tests/sqlparser_sqlite.rs

@@ -596,6 +596,104 @@ fn test_dollar_identifier_as_placeholder() {
     }
 }
 
+#[test]
+fn parse_sqlite_variable_tokens() {
+    for sql in [
+        "SELECT #a",
+        "SELECT @a",
+        "SELECT :a",
+        "SELECT $a",
+        "SELECT @2t",
+        "SELECT :9c",
+        "SELECT @a$",
+        "SELECT :a$",
+        "SELECT :a()",
+        "SELECT :a(x)",
+        "SELECT @a()",
+        "SELECT :::6",
+        "SELECT :a::b",
+        "SELECT $a::b",
+        "SELECT @::b",
+        "SELECT #::b",
+        "SELECT ($$::)",
+        "SELECT @\u{00e9}",
+        "SELECT :\u{00e9}",
+        "SELECT #\u{00e9}",
+        "SELECT :::\u{00e9}",
+    ] {
+        sqlite().verified_stmt(sql);
+    }
+    sqlite().one_statement_parses_to("SELECT @2t i", "SELECT @2t AS i");
+
+    let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]);
+    for (sql, err) in [
+        (
+            "SELECT :::6",
+            ParserError::ParserError("Expected: an expression, found: ::".to_string()),
+        ),
+        (
+            "SELECT ($$::)",
+            ParserError::TokenizerError(
+                "Unterminated dollar-quoted string at Line: 1, Column: 14".to_string(),
+            ),
+        ),
+    ] {
+        assert_eq!(generic.parse_sql_statements(sql), Err(err), "{sql}");
+    }
+    // SQLite ends a subscript at whitespace and rejects the token
+    assert_eq!(
+        sqlite().parse_sql_statements("SELECT $a(x y)"),
+        Err(ParserError::TokenizerError(
+            "Unterminated SQLite variable subscript at Line: 1, Column: 8".to_string()
+        ))
+    );
+    // A vertical tab also ends a subscript in SQLite's tokenizer
+    assert_eq!(
+        sqlite().parse_sql_statements("SELECT :a(x\u{000b}y)"),
+        Err(ParserError::TokenizerError(
+            "Unterminated SQLite variable subscript at Line: 1, Column: 8".to_string()
+        ))
+    );
+}
+
+#[test]
+fn parse_colon_is_not_an_operator() {
+    for (sql, err) in [
+        (
+            "SELECT b : c",
+            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
+        ),
+        (
+            "SELECT a / b : c",
+            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
+        ),
+        (
+            "SELECT b : c.d",
+            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
+        ),
+        (
+            "SELECT b : \"c\"",
+            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
+        ),
+        (
+            "SELECT b :c",
+            ParserError::ParserError("Expected: end of statement, found: :c".to_string()),
+        ),
+    ] {
+        assert_eq!(sqlite().parse_sql_statements(sql), Err(err), "{sql}");
+    }
+    sqlite().verified_stmt("SELECT a FROM t WHERE b = :c");
+}
+
+#[test]
+fn tokenize_hash_digit_is_not_a_variable() {
+    let tokens = Tokenizer::new(&SQLiteDialect {}, "#123")
+        .tokenize()
+        .unwrap();
+    let expected = vec![Token::Sharp, Token::Number("123".to_string(), false)];
+    assert_eq!(tokens, expected);
+}
+
 #[test]
 fn test_match_operator() {
     assert_eq!(
@@ -1464,101 +1562,3 @@ fn parse_bitwise_and_or_share_precedence() {
         assert_eq!(sqlite().verified_expr(sql), expected, "{sql}");
     }
 }
-
-#[test]
-fn parse_sqlite_variable_tokens() {
-    for sql in [
-        "SELECT #a",
-        "SELECT @a",
-        "SELECT :a",
-        "SELECT $a",
-        "SELECT @2t",
-        "SELECT :9c",
-        "SELECT @a$",
-        "SELECT :a$",
-        "SELECT :a()",
-        "SELECT :a(x)",
-        "SELECT @a()",
-        "SELECT :::6",
-        "SELECT :a::b",
-        "SELECT $a::b",
-        "SELECT @::b",
-        "SELECT #::b",
-        "SELECT ($$::)",
-        "SELECT @\u{00e9}",
-        "SELECT :\u{00e9}",
-        "SELECT #\u{00e9}",
-        "SELECT :::\u{00e9}",
-    ] {
-        sqlite().verified_stmt(sql);
-    }
-    sqlite().one_statement_parses_to("SELECT @2t i", "SELECT @2t AS i");
-
-    let generic = TestedDialects::new(vec![Box::new(GenericDialect {})]);
-    for (sql, err) in [
-        (
-            "SELECT :::6",
-            ParserError::ParserError("Expected: an expression, found: ::".to_string()),
-        ),
-        (
-            "SELECT ($$::)",
-            ParserError::TokenizerError(
-                "Unterminated dollar-quoted string at Line: 1, Column: 14".to_string(),
-            ),
-        ),
-    ] {
-        assert_eq!(generic.parse_sql_statements(sql), Err(err), "{sql}");
-    }
-    // SQLite ends a subscript at whitespace and rejects the token
-    assert_eq!(
-        sqlite().parse_sql_statements("SELECT $a(x y)"),
-        Err(ParserError::TokenizerError(
-            "Unterminated SQLite variable subscript at Line: 1, Column: 8".to_string()
-        ))
-    );
-    // A vertical tab also ends a subscript in SQLite's tokenizer
-    assert_eq!(
-        sqlite().parse_sql_statements("SELECT :a(x\u{000b}y)"),
-        Err(ParserError::TokenizerError(
-            "Unterminated SQLite variable subscript at Line: 1, Column: 8".to_string()
-        ))
-    );
-}
-
-#[test]
-fn parse_colon_is_not_an_operator() {
-    for (sql, err) in [
-        (
-            "SELECT b : c",
-            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
-        ),
-        (
-            "SELECT a / b : c",
-            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
-        ),
-        (
-            "SELECT b : c.d",
-            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
-        ),
-        (
-            "SELECT b : \"c\"",
-            ParserError::ParserError("Expected: end of statement, found: :".to_string()),
-        ),
-        (
-            "SELECT b :c",
-            ParserError::ParserError("Expected: end of statement, found: :c".to_string()),
-        ),
-    ] {
-        assert_eq!(sqlite().parse_sql_statements(sql), Err(err), "{sql}");
-    }
-    sqlite().verified_stmt("SELECT a FROM t WHERE b = :c");
-}
-
-#[test]
-fn tokenize_hash_digit_is_not_a_variable() {
-    let tokens = Tokenizer::new(&SQLiteDialect {}, "#123")
-        .tokenize()
-        .unwrap();
-    let expected = vec![Token::Sharp, Token::Number("123".to_string(), false)];
-    assert_eq!(tokens, expected);
-}