From d17687e5a64d78ecc2bfeedb81a8c503453b02c9 Mon Sep 17 00:00:00 2001
From: Kyler <yrea2001@gmail.com>
Date: Mon, 1 Dec 2025 22:33:51 -0700
Subject: [PATCH] Changed test function names to be snake case

---
 SLS_Rust/sls/tests/lexer_tests_generated.rs | 875 ++++++++++----------
 SLS_Tests/cases.yaml                        | 104 +--
 SLS_Tests/generate_tests/char_tests.py      |   8 +-
 SLS_Tests/yaml_to_rust_tests.py             |   1 +
 4 files changed, 494 insertions(+), 494 deletions(-)

diff --git a/SLS_Rust/sls/tests/lexer_tests_generated.rs b/SLS_Rust/sls/tests/lexer_tests_generated.rs
index 8fac3b6..f02e4bd 100644
--- a/SLS_Rust/sls/tests/lexer_tests_generated.rs
+++ b/SLS_Rust/sls/tests/lexer_tests_generated.rs
@@ -7,7 +7,7 @@ const INT64_MIN: i128 = i64::MIN as i128;
 const UINT64_MAX: i128 = u64::MAX as i128;
 
 #[test]
-fn test_Empty_Statement() {
+fn test_empty_statement() {
     let src = "";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -21,7 +21,7 @@ fn test_Empty_Statement() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_0() {
+fn test_integer_default_decimal_0() {
     let src = "0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -38,7 +38,7 @@ fn test_Integer_Default_Decimal_0() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_1() {
+fn test_integer_default_decimal_1() {
     let src = "-1";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -55,7 +55,7 @@ fn test_Integer_Default_Decimal_1() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_42() {
+fn test_integer_default_decimal_42() {
     let src = "42";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -72,7 +72,7 @@ fn test_Integer_Default_Decimal_42() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_Leading_Zeros() {
+fn test_integer_default_decimal_leading_zeros() {
     let src = "00042";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -89,7 +89,7 @@ fn test_Integer_Default_Decimal_Leading_Zeros() {
 }
 
 #[test]
-fn test_Integer_Default_Hex_0xFF() {
+fn test_integer_default_hex_0xff() {
     let src = "0xFF";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -106,7 +106,7 @@ fn test_Integer_Default_Hex_0xFF() {
 }
 
 #[test]
-fn test_Integer_Default_Hex_0xdeadbeef() {
+fn test_integer_default_hex_0xdeadbeef() {
     let src = "0xdeadbeef";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -123,7 +123,7 @@ fn test_Integer_Default_Hex_0xdeadbeef() {
 }
 
 #[test]
-fn test_Integer_Default_Hex_Max() {
+fn test_integer_default_hex_max() {
     let src = "0x7FFFFFFFFFFFFFFF";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -140,7 +140,7 @@ fn test_Integer_Default_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_Default_Binary_0b1010() {
+fn test_integer_default_binary_0b1010() {
     let src = "0b1010";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -157,7 +157,7 @@ fn test_Integer_Default_Binary_0b1010() {
 }
 
 #[test]
-fn test_Integer_Default_Binary_All_Ones() {
+fn test_integer_default_binary_all_ones() {
     let src = "0b1111111111111111";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -174,7 +174,7 @@ fn test_Integer_Default_Binary_All_Ones() {
 }
 
 #[test]
-fn test_Integer_Default_Octal_0o755() {
+fn test_integer_default_octal_0o755() {
     let src = "0o755";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -191,7 +191,7 @@ fn test_Integer_Default_Octal_0o755() {
 }
 
 #[test]
-fn test_Integer_Default_Octal_Max_Three_Digits() {
+fn test_integer_default_octal_max_three_digits() {
     let src = "0o777";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -208,7 +208,7 @@ fn test_Integer_Default_Octal_Max_Three_Digits() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_Max_i64() {
+fn test_integer_default_decimal_max_i64() {
     let src = "9223372036854775807";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -225,7 +225,7 @@ fn test_Integer_Default_Decimal_Max_i64() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_Min_i64() {
+fn test_integer_default_decimal_min_i64() {
     let src = "-9223372036854775808";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -242,7 +242,7 @@ fn test_Integer_Default_Decimal_Min_i64() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_with_Underscore() {
+fn test_integer_default_decimal_with_underscore() {
     let src = "1_000_000";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -259,7 +259,7 @@ fn test_Integer_Default_Decimal_with_Underscore() {
 }
 
 #[test]
-fn test_Integer_Default_Underscore_End() {
+fn test_integer_default_underscore_end() {
     let src = "42_";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -276,7 +276,7 @@ fn test_Integer_Default_Underscore_End() {
 }
 
 #[test]
-fn test_Integer_Default_Underscore_Double() {
+fn test_integer_default_underscore_double() {
     let src = "4__2";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -293,7 +293,7 @@ fn test_Integer_Default_Underscore_Double() {
 }
 
 #[test]
-fn test_Integer_Default_Whitespace() {
+fn test_integer_default_whitespace() {
     let src = "  42  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -310,7 +310,7 @@ fn test_Integer_Default_Whitespace() {
 }
 
 #[test]
-fn test_Integer_Default_Hex_Zero() {
+fn test_integer_default_hex_zero() {
     let src = "0x0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -327,7 +327,7 @@ fn test_Integer_Default_Hex_Zero() {
 }
 
 #[test]
-fn test_Integer_Default_Binary_Zero() {
+fn test_integer_default_binary_zero() {
     let src = "0b0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -344,7 +344,7 @@ fn test_Integer_Default_Binary_Zero() {
 }
 
 #[test]
-fn test_Integer_Default_Octal_Zero() {
+fn test_integer_default_octal_zero() {
     let src = "0o0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -361,7 +361,7 @@ fn test_Integer_Default_Octal_Zero() {
 }
 
 #[test]
-fn test_Integer_Default_Decimal_with_Commas_Invalid() {
+fn test_integer_default_decimal_with_commas_invalid() {
     let src = "1,000,000";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -376,7 +376,7 @@ fn test_Integer_Default_Decimal_with_Commas_Invalid() {
 }
 
 #[test]
-fn test_Integer_Default_Invalid_Characters() {
+fn test_integer_default_invalid_characters() {
     let src = "12a3";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -391,7 +391,7 @@ fn test_Integer_Default_Invalid_Characters() {
 }
 
 #[test]
-fn test_Integer_Default_Invalid_Prefix() {
+fn test_integer_default_invalid_prefix() {
     let src = "0b2";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -406,7 +406,7 @@ fn test_Integer_Default_Invalid_Prefix() {
 }
 
 #[test]
-fn test_Integer_i8_Decimal_Positive() {
+fn test_integer_i8_decimal_positive() {
     let src = "42:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -423,7 +423,7 @@ fn test_Integer_i8_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_i8_Zero() {
+fn test_integer_i8_zero() {
     let src = "0:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -440,7 +440,7 @@ fn test_Integer_i8_Zero() {
 }
 
 #[test]
-fn test_Integer_i8_Decimal_Negative() {
+fn test_integer_i8_decimal_negative() {
     let src = "-100:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -457,7 +457,7 @@ fn test_Integer_i8_Decimal_Negative() {
 }
 
 #[test]
-fn test_Integer_i8_Hex() {
+fn test_integer_i8_hex() {
     let src = "0x7F:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -474,7 +474,7 @@ fn test_Integer_i8_Hex() {
 }
 
 #[test]
-fn test_Integer_i8_Binary() {
+fn test_integer_i8_binary() {
     let src = "0b1111:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -491,7 +491,7 @@ fn test_Integer_i8_Binary() {
 }
 
 #[test]
-fn test_Integer_i8_Octal() {
+fn test_integer_i8_octal() {
     let src = "0o77:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -508,7 +508,7 @@ fn test_Integer_i8_Octal() {
 }
 
 #[test]
-fn test_Integer_i8_Max_Value() {
+fn test_integer_i8_max_value() {
     let src = "127:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -525,7 +525,7 @@ fn test_Integer_i8_Max_Value() {
 }
 
 #[test]
-fn test_Integer_i8_Min_Value() {
+fn test_integer_i8_min_value() {
     let src = "-128:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -542,7 +542,7 @@ fn test_Integer_i8_Min_Value() {
 }
 
 #[test]
-fn test_Integer_i8_Overflow() {
+fn test_integer_i8_overflow() {
     let src = "128:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -557,7 +557,7 @@ fn test_Integer_i8_Overflow() {
 }
 
 #[test]
-fn test_Integer_i8_Underflow() {
+fn test_integer_i8_underflow() {
     let src = "-129:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -572,7 +572,7 @@ fn test_Integer_i8_Underflow() {
 }
 
 #[test]
-fn test_Integer_i16_Decimal_Positive() {
+fn test_integer_i16_decimal_positive() {
     let src = "42:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -589,7 +589,7 @@ fn test_Integer_i16_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_i16_Zero() {
+fn test_integer_i16_zero() {
     let src = "0:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -606,7 +606,7 @@ fn test_Integer_i16_Zero() {
 }
 
 #[test]
-fn test_Integer_i16_Decimal_Negative() {
+fn test_integer_i16_decimal_negative() {
     let src = "-100:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -623,7 +623,7 @@ fn test_Integer_i16_Decimal_Negative() {
 }
 
 #[test]
-fn test_Integer_i16_Hex() {
+fn test_integer_i16_hex() {
     let src = "0xFF:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -640,7 +640,7 @@ fn test_Integer_i16_Hex() {
 }
 
 #[test]
-fn test_Integer_i16_Binary() {
+fn test_integer_i16_binary() {
     let src = "0b1111:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -657,7 +657,7 @@ fn test_Integer_i16_Binary() {
 }
 
 #[test]
-fn test_Integer_i16_Octal() {
+fn test_integer_i16_octal() {
     let src = "0o77:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -674,7 +674,7 @@ fn test_Integer_i16_Octal() {
 }
 
 #[test]
-fn test_Integer_i16_Max_Value() {
+fn test_integer_i16_max_value() {
     let src = "32767:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -691,7 +691,7 @@ fn test_Integer_i16_Max_Value() {
 }
 
 #[test]
-fn test_Integer_i16_Min_Value() {
+fn test_integer_i16_min_value() {
     let src = "-32768:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -708,7 +708,7 @@ fn test_Integer_i16_Min_Value() {
 }
 
 #[test]
-fn test_Integer_i16_Overflow() {
+fn test_integer_i16_overflow() {
     let src = "32768:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -723,7 +723,7 @@ fn test_Integer_i16_Overflow() {
 }
 
 #[test]
-fn test_Integer_i16_Underflow() {
+fn test_integer_i16_underflow() {
     let src = "-32769:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -738,7 +738,7 @@ fn test_Integer_i16_Underflow() {
 }
 
 #[test]
-fn test_Integer_i32_Decimal_Positive() {
+fn test_integer_i32_decimal_positive() {
     let src = "42:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -755,7 +755,7 @@ fn test_Integer_i32_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_i32_Zero() {
+fn test_integer_i32_zero() {
     let src = "0:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -772,7 +772,7 @@ fn test_Integer_i32_Zero() {
 }
 
 #[test]
-fn test_Integer_i32_Decimal_Negative() {
+fn test_integer_i32_decimal_negative() {
     let src = "-100:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -789,7 +789,7 @@ fn test_Integer_i32_Decimal_Negative() {
 }
 
 #[test]
-fn test_Integer_i32_Hex() {
+fn test_integer_i32_hex() {
     let src = "0xFF:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -806,7 +806,7 @@ fn test_Integer_i32_Hex() {
 }
 
 #[test]
-fn test_Integer_i32_Binary() {
+fn test_integer_i32_binary() {
     let src = "0b1111:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -823,7 +823,7 @@ fn test_Integer_i32_Binary() {
 }
 
 #[test]
-fn test_Integer_i32_Octal() {
+fn test_integer_i32_octal() {
     let src = "0o77:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -840,7 +840,7 @@ fn test_Integer_i32_Octal() {
 }
 
 #[test]
-fn test_Integer_i32_Max_Value() {
+fn test_integer_i32_max_value() {
     let src = "2147483647:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -857,7 +857,7 @@ fn test_Integer_i32_Max_Value() {
 }
 
 #[test]
-fn test_Integer_i32_Min_Value() {
+fn test_integer_i32_min_value() {
     let src = "-2147483648:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -874,7 +874,7 @@ fn test_Integer_i32_Min_Value() {
 }
 
 #[test]
-fn test_Integer_i32_Overflow() {
+fn test_integer_i32_overflow() {
     let src = "2147483648:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -889,7 +889,7 @@ fn test_Integer_i32_Overflow() {
 }
 
 #[test]
-fn test_Integer_i32_Underflow() {
+fn test_integer_i32_underflow() {
     let src = "-2147483649:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -904,7 +904,7 @@ fn test_Integer_i32_Underflow() {
 }
 
 #[test]
-fn test_Integer_i32_With_Underscores() {
+fn test_integer_i32_with_underscores() {
     let src = "1_000_000:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -921,7 +921,7 @@ fn test_Integer_i32_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_i64_Decimal_Positive() {
+fn test_integer_i64_decimal_positive() {
     let src = "42:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -938,7 +938,7 @@ fn test_Integer_i64_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_i64_Zero() {
+fn test_integer_i64_zero() {
     let src = "0:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -955,7 +955,7 @@ fn test_Integer_i64_Zero() {
 }
 
 #[test]
-fn test_Integer_i64_Decimal_Negative() {
+fn test_integer_i64_decimal_negative() {
     let src = "-100:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -972,7 +972,7 @@ fn test_Integer_i64_Decimal_Negative() {
 }
 
 #[test]
-fn test_Integer_i64_Hex() {
+fn test_integer_i64_hex() {
     let src = "0xFF:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -989,7 +989,7 @@ fn test_Integer_i64_Hex() {
 }
 
 #[test]
-fn test_Integer_i64_Binary() {
+fn test_integer_i64_binary() {
     let src = "0b1111:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1006,7 +1006,7 @@ fn test_Integer_i64_Binary() {
 }
 
 #[test]
-fn test_Integer_i64_Octal() {
+fn test_integer_i64_octal() {
     let src = "0o77:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1023,7 +1023,7 @@ fn test_Integer_i64_Octal() {
 }
 
 #[test]
-fn test_Integer_i64_Max_Value() {
+fn test_integer_i64_max_value() {
     let src = "9223372036854775807:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1040,7 +1040,7 @@ fn test_Integer_i64_Max_Value() {
 }
 
 #[test]
-fn test_Integer_i64_Min_Value() {
+fn test_integer_i64_min_value() {
     let src = "-9223372036854775808:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1057,7 +1057,7 @@ fn test_Integer_i64_Min_Value() {
 }
 
 #[test]
-fn test_Integer_i64_Overflow() {
+fn test_integer_i64_overflow() {
     let src = "9223372036854775808:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1072,7 +1072,7 @@ fn test_Integer_i64_Overflow() {
 }
 
 #[test]
-fn test_Integer_i64_Underflow() {
+fn test_integer_i64_underflow() {
     let src = "-9223372036854775809:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1087,7 +1087,7 @@ fn test_Integer_i64_Underflow() {
 }
 
 #[test]
-fn test_Integer_i64_With_Underscores() {
+fn test_integer_i64_with_underscores() {
     let src = "1_000_000:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1104,7 +1104,7 @@ fn test_Integer_i64_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_u8_Decimal_Positive() {
+fn test_integer_u8_decimal_positive() {
     let src = "42:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1121,7 +1121,7 @@ fn test_Integer_u8_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_u8_Zero() {
+fn test_integer_u8_zero() {
     let src = "0:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1138,7 +1138,7 @@ fn test_Integer_u8_Zero() {
 }
 
 #[test]
-fn test_Integer_u8_Hex() {
+fn test_integer_u8_hex() {
     let src = "0xFF:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1155,7 +1155,7 @@ fn test_Integer_u8_Hex() {
 }
 
 #[test]
-fn test_Integer_u8_Binary() {
+fn test_integer_u8_binary() {
     let src = "0b1111:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1172,7 +1172,7 @@ fn test_Integer_u8_Binary() {
 }
 
 #[test]
-fn test_Integer_u8_Octal() {
+fn test_integer_u8_octal() {
     let src = "0o77:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1189,7 +1189,7 @@ fn test_Integer_u8_Octal() {
 }
 
 #[test]
-fn test_Integer_u8_Max_Value() {
+fn test_integer_u8_max_value() {
     let src = "255:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1206,7 +1206,7 @@ fn test_Integer_u8_Max_Value() {
 }
 
 #[test]
-fn test_Integer_u8_Min_Value() {
+fn test_integer_u8_min_value() {
     let src = "0:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1223,7 +1223,7 @@ fn test_Integer_u8_Min_Value() {
 }
 
 #[test]
-fn test_Integer_u8_Overflow() {
+fn test_integer_u8_overflow() {
     let src = "256:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1238,7 +1238,7 @@ fn test_Integer_u8_Overflow() {
 }
 
 #[test]
-fn test_Integer_u8_Underflow() {
+fn test_integer_u8_underflow() {
     let src = "-1:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1253,7 +1253,7 @@ fn test_Integer_u8_Underflow() {
 }
 
 #[test]
-fn test_Integer_u16_Decimal_Positive() {
+fn test_integer_u16_decimal_positive() {
     let src = "42:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1270,7 +1270,7 @@ fn test_Integer_u16_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_u16_Zero() {
+fn test_integer_u16_zero() {
     let src = "0:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1287,7 +1287,7 @@ fn test_Integer_u16_Zero() {
 }
 
 #[test]
-fn test_Integer_u16_Hex() {
+fn test_integer_u16_hex() {
     let src = "0xFF:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1304,7 +1304,7 @@ fn test_Integer_u16_Hex() {
 }
 
 #[test]
-fn test_Integer_u16_Binary() {
+fn test_integer_u16_binary() {
     let src = "0b1111:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1321,7 +1321,7 @@ fn test_Integer_u16_Binary() {
 }
 
 #[test]
-fn test_Integer_u16_Octal() {
+fn test_integer_u16_octal() {
     let src = "0o77:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1338,7 +1338,7 @@ fn test_Integer_u16_Octal() {
 }
 
 #[test]
-fn test_Integer_u16_Max_Value() {
+fn test_integer_u16_max_value() {
     let src = "65535:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1355,7 +1355,7 @@ fn test_Integer_u16_Max_Value() {
 }
 
 #[test]
-fn test_Integer_u16_Min_Value() {
+fn test_integer_u16_min_value() {
     let src = "0:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1372,7 +1372,7 @@ fn test_Integer_u16_Min_Value() {
 }
 
 #[test]
-fn test_Integer_u16_Overflow() {
+fn test_integer_u16_overflow() {
     let src = "65536:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1387,7 +1387,7 @@ fn test_Integer_u16_Overflow() {
 }
 
 #[test]
-fn test_Integer_u16_Underflow() {
+fn test_integer_u16_underflow() {
     let src = "-1:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1402,7 +1402,7 @@ fn test_Integer_u16_Underflow() {
 }
 
 #[test]
-fn test_Integer_u32_Decimal_Positive() {
+fn test_integer_u32_decimal_positive() {
     let src = "42:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1419,7 +1419,7 @@ fn test_Integer_u32_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_u32_Zero() {
+fn test_integer_u32_zero() {
     let src = "0:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1436,7 +1436,7 @@ fn test_Integer_u32_Zero() {
 }
 
 #[test]
-fn test_Integer_u32_Hex() {
+fn test_integer_u32_hex() {
     let src = "0xFF:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1453,7 +1453,7 @@ fn test_Integer_u32_Hex() {
 }
 
 #[test]
-fn test_Integer_u32_Binary() {
+fn test_integer_u32_binary() {
     let src = "0b1111:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1470,7 +1470,7 @@ fn test_Integer_u32_Binary() {
 }
 
 #[test]
-fn test_Integer_u32_Octal() {
+fn test_integer_u32_octal() {
     let src = "0o77:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1487,7 +1487,7 @@ fn test_Integer_u32_Octal() {
 }
 
 #[test]
-fn test_Integer_u32_Max_Value() {
+fn test_integer_u32_max_value() {
     let src = "4294967295:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1504,7 +1504,7 @@ fn test_Integer_u32_Max_Value() {
 }
 
 #[test]
-fn test_Integer_u32_Min_Value() {
+fn test_integer_u32_min_value() {
     let src = "0:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1521,7 +1521,7 @@ fn test_Integer_u32_Min_Value() {
 }
 
 #[test]
-fn test_Integer_u32_Overflow() {
+fn test_integer_u32_overflow() {
     let src = "4294967296:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1536,7 +1536,7 @@ fn test_Integer_u32_Overflow() {
 }
 
 #[test]
-fn test_Integer_u32_Underflow() {
+fn test_integer_u32_underflow() {
     let src = "-1:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1551,7 +1551,7 @@ fn test_Integer_u32_Underflow() {
 }
 
 #[test]
-fn test_Integer_u32_With_Underscores() {
+fn test_integer_u32_with_underscores() {
     let src = "1_000_000:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1568,7 +1568,7 @@ fn test_Integer_u32_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_u64_Decimal_Positive() {
+fn test_integer_u64_decimal_positive() {
     let src = "42:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1585,7 +1585,7 @@ fn test_Integer_u64_Decimal_Positive() {
 }
 
 #[test]
-fn test_Integer_u64_Zero() {
+fn test_integer_u64_zero() {
     let src = "0:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1602,7 +1602,7 @@ fn test_Integer_u64_Zero() {
 }
 
 #[test]
-fn test_Integer_u64_Hex() {
+fn test_integer_u64_hex() {
     let src = "0xFF:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1619,7 +1619,7 @@ fn test_Integer_u64_Hex() {
 }
 
 #[test]
-fn test_Integer_u64_Binary() {
+fn test_integer_u64_binary() {
     let src = "0b1111:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1636,7 +1636,7 @@ fn test_Integer_u64_Binary() {
 }
 
 #[test]
-fn test_Integer_u64_Octal() {
+fn test_integer_u64_octal() {
     let src = "0o77:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1653,7 +1653,7 @@ fn test_Integer_u64_Octal() {
 }
 
 #[test]
-fn test_Integer_u64_Max_Value() {
+fn test_integer_u64_max_value() {
     let src = "18446744073709551615:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1670,7 +1670,7 @@ fn test_Integer_u64_Max_Value() {
 }
 
 #[test]
-fn test_Integer_u64_Min_Value() {
+fn test_integer_u64_min_value() {
     let src = "0:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1687,7 +1687,7 @@ fn test_Integer_u64_Min_Value() {
 }
 
 #[test]
-fn test_Integer_u64_Overflow() {
+fn test_integer_u64_overflow() {
     let src = "18446744073709551616:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1702,7 +1702,7 @@ fn test_Integer_u64_Overflow() {
 }
 
 #[test]
-fn test_Integer_u64_Underflow() {
+fn test_integer_u64_underflow() {
     let src = "-1:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1717,7 +1717,7 @@ fn test_Integer_u64_Underflow() {
 }
 
 #[test]
-fn test_Integer_u64_With_Underscores() {
+fn test_integer_u64_with_underscores() {
     let src = "1_000_000:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1734,7 +1734,7 @@ fn test_Integer_u64_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_i8_Hex_Max() {
+fn test_integer_i8_hex_max() {
     let src = "0x7F:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1751,7 +1751,7 @@ fn test_Integer_i8_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_i8_Binary_Max() {
+fn test_integer_i8_binary_max() {
     let src = "0b01111111:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1768,7 +1768,7 @@ fn test_Integer_i8_Binary_Max() {
 }
 
 #[test]
-fn test_Integer_i8_Octal_Max() {
+fn test_integer_i8_octal_max() {
     let src = "0o177:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1785,7 +1785,7 @@ fn test_Integer_i8_Octal_Max() {
 }
 
 #[test]
-fn test_Integer_i8_Negative_Hex() {
+fn test_integer_i8_negative_hex() {
     let src = "-0x80:i8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1802,7 +1802,7 @@ fn test_Integer_i8_Negative_Hex() {
 }
 
 #[test]
-fn test_Integer_u8_Hex_Max() {
+fn test_integer_u8_hex_max() {
     let src = "0xFF:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1819,7 +1819,7 @@ fn test_Integer_u8_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_u8_Binary_Max() {
+fn test_integer_u8_binary_max() {
     let src = "0b11111111:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1836,7 +1836,7 @@ fn test_Integer_u8_Binary_Max() {
 }
 
 #[test]
-fn test_Integer_u8_Octal_Max() {
+fn test_integer_u8_octal_max() {
     let src = "0o377:u8";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1853,7 +1853,7 @@ fn test_Integer_u8_Octal_Max() {
 }
 
 #[test]
-fn test_Integer_i16_Hex_Sample() {
+fn test_integer_i16_hex_sample() {
     let src = "0x1234:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1870,7 +1870,7 @@ fn test_Integer_i16_Hex_Sample() {
 }
 
 #[test]
-fn test_Integer_i16_Binary_Sample() {
+fn test_integer_i16_binary_sample() {
     let src = "0b1111111100000000:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1887,7 +1887,7 @@ fn test_Integer_i16_Binary_Sample() {
 }
 
 #[test]
-fn test_Integer_i16_Octal_Sample() {
+fn test_integer_i16_octal_sample() {
     let src = "0o1234:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1904,7 +1904,7 @@ fn test_Integer_i16_Octal_Sample() {
 }
 
 #[test]
-fn test_Integer_u16_Hex_Max() {
+fn test_integer_u16_hex_max() {
     let src = "0xFFFF:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1921,7 +1921,7 @@ fn test_Integer_u16_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_u16_Binary_Max() {
+fn test_integer_u16_binary_max() {
     let src = "0b1111111111111111:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1938,7 +1938,7 @@ fn test_Integer_u16_Binary_Max() {
 }
 
 #[test]
-fn test_Integer_u16_Octal_Max() {
+fn test_integer_u16_octal_max() {
     let src = "0o177777:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1955,7 +1955,7 @@ fn test_Integer_u16_Octal_Max() {
 }
 
 #[test]
-fn test_Integer_u16_Decimal_Mid() {
+fn test_integer_u16_decimal_mid() {
     let src = "50000:u16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1972,7 +1972,7 @@ fn test_Integer_u16_Decimal_Mid() {
 }
 
 #[test]
-fn test_Integer_i32_Hex_Sample() {
+fn test_integer_i32_hex_sample() {
     let src = "0xABCD:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -1989,7 +1989,7 @@ fn test_Integer_i32_Hex_Sample() {
 }
 
 #[test]
-fn test_Integer_i32_Binary_Sample() {
+fn test_integer_i32_binary_sample() {
     let src = "0b11110000:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2006,7 +2006,7 @@ fn test_Integer_i32_Binary_Sample() {
 }
 
 #[test]
-fn test_Integer_u32_Hex_Max() {
+fn test_integer_u32_hex_max() {
     let src = "0xFFFFFFFF:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2023,7 +2023,7 @@ fn test_Integer_u32_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_u32_Binary_Sample() {
+fn test_integer_u32_binary_sample() {
     let src = "0b11111111000000001111111100000000:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2040,7 +2040,7 @@ fn test_Integer_u32_Binary_Sample() {
 }
 
 #[test]
-fn test_Integer_u32_Octal_Max() {
+fn test_integer_u32_octal_max() {
     let src = "0o37777777777:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2057,7 +2057,7 @@ fn test_Integer_u32_Octal_Max() {
 }
 
 #[test]
-fn test_Integer_u32_Decimal_Mid() {
+fn test_integer_u32_decimal_mid() {
     let src = "1000000:u32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2074,7 +2074,7 @@ fn test_Integer_u32_Decimal_Mid() {
 }
 
 #[test]
-fn test_Integer_i64_Decimal_Positive_42() {
+fn test_integer_i64_decimal_positive_42() {
     let src = "42:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2091,7 +2091,7 @@ fn test_Integer_i64_Decimal_Positive_42() {
 }
 
 #[test]
-fn test_Integer_i64_Hex_0xFF() {
+fn test_integer_i64_hex_0xff() {
     let src = "0xFF:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2108,7 +2108,7 @@ fn test_Integer_i64_Hex_0xFF() {
 }
 
 #[test]
-fn test_Integer_i64_Binary_0b1010() {
+fn test_integer_i64_binary_0b1010() {
     let src = "0b1010:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2125,7 +2125,7 @@ fn test_Integer_i64_Binary_0b1010() {
 }
 
 #[test]
-fn test_Integer_i64_Octal_0o755() {
+fn test_integer_i64_octal_0o755() {
     let src = "0o755:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2142,7 +2142,7 @@ fn test_Integer_i64_Octal_0o755() {
 }
 
 #[test]
-fn test_Integer_u64_Hex_Max() {
+fn test_integer_u64_hex_max() {
     let src = "0xFFFFFFFFFFFFFFFF:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2159,7 +2159,7 @@ fn test_Integer_u64_Hex_Max() {
 }
 
 #[test]
-fn test_Integer_u64_Binary_Sample() {
+fn test_integer_u64_binary_sample() {
     let src = "0b1010101010101010:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2176,7 +2176,7 @@ fn test_Integer_u64_Binary_Sample() {
 }
 
 #[test]
-fn test_Integer_u64_Octal_Sample() {
+fn test_integer_u64_octal_sample() {
     let src = "0o7777:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2193,7 +2193,7 @@ fn test_Integer_u64_Octal_Sample() {
 }
 
 #[test]
-fn test_Integer_u64_Decimal() {
+fn test_integer_u64_decimal() {
     let src = "42:u64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2210,7 +2210,7 @@ fn test_Integer_u64_Decimal() {
 }
 
 #[test]
-fn test_Integer_Hex_With_Underscores() {
+fn test_integer_hex_with_underscores() {
     let src = "0xDEAD_BEEF:i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2227,7 +2227,7 @@ fn test_Integer_Hex_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_Binary_With_Underscores() {
+fn test_integer_binary_with_underscores() {
     let src = "0b1111_0000_1010_0101:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2244,7 +2244,7 @@ fn test_Integer_Binary_With_Underscores() {
 }
 
 #[test]
-fn test_Integer_Octal_With_Underscores() {
+fn test_integer_octal_with_underscores() {
     let src = "0o7_7_7:i16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2261,7 +2261,7 @@ fn test_Integer_Octal_With_Underscores() {
 }
 
 #[test]
-fn test_Float_Default_Simple() {
+fn test_float_default_simple() {
     let src = "3.14";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2278,7 +2278,7 @@ fn test_Float_Default_Simple() {
 }
 
 #[test]
-fn test_Float_Default_Zero() {
+fn test_float_default_zero() {
     let src = "0.0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2295,7 +2295,7 @@ fn test_Float_Default_Zero() {
 }
 
 #[test]
-fn test_Float_Default_Negative() {
+fn test_float_default_negative() {
     let src = "-2.5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2312,7 +2312,7 @@ fn test_Float_Default_Negative() {
 }
 
 #[test]
-fn test_Float_Default_One() {
+fn test_float_default_one() {
     let src = "1.0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2329,7 +2329,7 @@ fn test_Float_Default_One() {
 }
 
 #[test]
-fn test_Float_f32_Simple() {
+fn test_float_f32_simple() {
     let src = "3.14:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2346,7 +2346,7 @@ fn test_Float_f32_Simple() {
 }
 
 #[test]
-fn test_Float_f64_Simple() {
+fn test_float_f64_simple() {
     let src = "2.718:f64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2363,7 +2363,7 @@ fn test_Float_f64_Simple() {
 }
 
 #[test]
-fn test_Float_Default_Leading_Zeros() {
+fn test_float_default_leading_zeros() {
     let src = "00042.5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2380,7 +2380,7 @@ fn test_Float_Default_Leading_Zeros() {
 }
 
 #[test]
-fn test_Float_Default_Leading_Zero_Decimal() {
+fn test_float_default_leading_zero_decimal() {
     let src = "0.5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2397,7 +2397,7 @@ fn test_Float_Default_Leading_Zero_Decimal() {
 }
 
 #[test]
-fn test_Float_Default_Trailing_Zeros() {
+fn test_float_default_trailing_zeros() {
     let src = "3.1400";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2414,7 +2414,7 @@ fn test_Float_Default_Trailing_Zeros() {
 }
 
 #[test]
-fn test_Float_Default_No_Leading_Digit() {
+fn test_float_default_no_leading_digit() {
     let src = ".5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2431,7 +2431,7 @@ fn test_Float_Default_No_Leading_Digit() {
 }
 
 #[test]
-fn test_Float_Default_No_Leading_Digit_Negative() {
+fn test_float_default_no_leading_digit_negative() {
     let src = "-.25";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2448,7 +2448,7 @@ fn test_Float_Default_No_Leading_Digit_Negative() {
 }
 
 #[test]
-fn test_Float_Default_No_Trailing_Digits() {
+fn test_float_default_no_trailing_digits() {
     let src = "42.";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2465,7 +2465,7 @@ fn test_Float_Default_No_Trailing_Digits() {
 }
 
 #[test]
-fn test_Float_Default_No_Trailing_Digits_Negative() {
+fn test_float_default_no_trailing_digits_negative() {
     let src = "-7.";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2482,7 +2482,7 @@ fn test_Float_Default_No_Trailing_Digits_Negative() {
 }
 
 #[test]
-fn test_Float_Default_Very_Small() {
+fn test_float_default_very_small() {
     let src = "0.000001";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2499,7 +2499,7 @@ fn test_Float_Default_Very_Small() {
 }
 
 #[test]
-fn test_Float_Default_Very_Large() {
+fn test_float_default_very_large() {
     let src = "1000000.0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2516,7 +2516,7 @@ fn test_Float_Default_Very_Large() {
 }
 
 #[test]
-fn test_Float_Default_Underscore_Integer_Part() {
+fn test_float_default_underscore_integer_part() {
     let src = "1_000_000.5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2533,7 +2533,7 @@ fn test_Float_Default_Underscore_Integer_Part() {
 }
 
 #[test]
-fn test_Float_Default_Underscore_Decimal_Part() {
+fn test_float_default_underscore_decimal_part() {
     let src = "3.141_592_653";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2550,7 +2550,7 @@ fn test_Float_Default_Underscore_Decimal_Part() {
 }
 
 #[test]
-fn test_Float_Default_Underscore_Both_Parts() {
+fn test_float_default_underscore_both_parts() {
     let src = "1_234.567_89";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2567,7 +2567,7 @@ fn test_Float_Default_Underscore_Both_Parts() {
 }
 
 #[test]
-fn test_Float_Default_Underscore_Trailing() {
+fn test_float_default_underscore_trailing() {
     let src = "42.5_";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2584,7 +2584,7 @@ fn test_Float_Default_Underscore_Trailing() {
 }
 
 #[test]
-fn test_Float_Default_Underscore_Double() {
+fn test_float_default_underscore_double() {
     let src = "4__2.5";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2601,7 +2601,7 @@ fn test_Float_Default_Underscore_Double() {
 }
 
 #[test]
-fn test_Float_f32_With_Underscores() {
+fn test_float_f32_with_underscores() {
     let src = "1_234.567_89:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2618,7 +2618,7 @@ fn test_Float_f32_With_Underscores() {
 }
 
 #[test]
-fn test_Float_f32_Precision_Limit() {
+fn test_float_f32_precision_limit() {
     let src = "1.2345678:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2635,7 +2635,7 @@ fn test_Float_f32_Precision_Limit() {
 }
 
 #[test]
-fn test_Float_f32_High_Precision() {
+fn test_float_f32_high_precision() {
     let src = "3.141592653589793:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2652,7 +2652,7 @@ fn test_Float_f32_High_Precision() {
 }
 
 #[test]
-fn test_Float_f64_Precision_Limit() {
+fn test_float_f64_precision_limit() {
     let src = "1.234567890123456:f64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2669,7 +2669,7 @@ fn test_Float_f64_Precision_Limit() {
 }
 
 #[test]
-fn test_Float_f64_High_Precision() {
+fn test_float_f64_high_precision() {
     let src = "3.141592653589793238:f64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2686,7 +2686,7 @@ fn test_Float_f64_High_Precision() {
 }
 
 #[test]
-fn test_Float_f64_Close_Numbers_1() {
+fn test_float_f64_close_numbers_1() {
     let src = "1.0000000000000001:f64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2703,7 +2703,7 @@ fn test_Float_f64_Close_Numbers_1() {
 }
 
 #[test]
-fn test_Float_f64_Close_Numbers_2() {
+fn test_float_f64_close_numbers_2() {
     let src = "1.0000000000000002:f64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2720,7 +2720,7 @@ fn test_Float_f64_Close_Numbers_2() {
 }
 
 #[test]
-fn test_Float_Invalid_Multiple_Decimal_Points() {
+fn test_float_invalid_multiple_decimal_points() {
     let src = "3.14.159";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2735,7 +2735,7 @@ fn test_Float_Invalid_Multiple_Decimal_Points() {
 }
 
 #[test]
-fn test_Float_Invalid_Characters() {
+fn test_float_invalid_characters() {
     let src = "3.1a4";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2750,7 +2750,7 @@ fn test_Float_Invalid_Characters() {
 }
 
 #[test]
-fn test_Float_Invalid_Type_Annotation() {
+fn test_float_invalid_type_annotation() {
     let src = "3.14:i32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2765,7 +2765,7 @@ fn test_Float_Invalid_Type_Annotation() {
 }
 
 #[test]
-fn test_Float_Invalid_Type_Name() {
+fn test_float_invalid_type_name() {
     let src = "3.14:f16";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2780,7 +2780,7 @@ fn test_Float_Invalid_Type_Name() {
 }
 
 #[test]
-fn test_Float_Invalid_Comma_Separator() {
+fn test_float_invalid_comma_separator() {
     let src = "1,234.56";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2795,7 +2795,7 @@ fn test_Float_Invalid_Comma_Separator() {
 }
 
 #[test]
-fn test_Float_Default_Leading_Whitespace() {
+fn test_float_default_leading_whitespace() {
     let src = "  3.14";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2812,7 +2812,7 @@ fn test_Float_Default_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Float_Default_Trailing_Whitespace() {
+fn test_float_default_trailing_whitespace() {
     let src = "3.14  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2829,7 +2829,7 @@ fn test_Float_Default_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Float_Default_Both_Whitespace() {
+fn test_float_default_both_whitespace() {
     let src = "  3.14  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2846,7 +2846,7 @@ fn test_Float_Default_Both_Whitespace() {
 }
 
 #[test]
-fn test_Float_f32_With_Whitespace() {
+fn test_float_f32_with_whitespace() {
     let src = "  2.718:f32  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2863,7 +2863,7 @@ fn test_Float_f32_With_Whitespace() {
 }
 
 #[test]
-fn test_Float_Default_Pi_Approximate() {
+fn test_float_default_pi_approximate() {
     let src = "3.141592653589793";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2880,7 +2880,7 @@ fn test_Float_Default_Pi_Approximate() {
 }
 
 #[test]
-fn test_Float_f32_Pi_Approximate() {
+fn test_float_f32_pi_approximate() {
     let src = "3.1415927:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2897,7 +2897,7 @@ fn test_Float_f32_Pi_Approximate() {
 }
 
 #[test]
-fn test_Float_Default_Euler_Approximate() {
+fn test_float_default_euler_approximate() {
     let src = "2.718281828459045";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2914,7 +2914,7 @@ fn test_Float_Default_Euler_Approximate() {
 }
 
 #[test]
-fn test_Float_f32_Euler_Approximate() {
+fn test_float_f32_euler_approximate() {
     let src = "2.7182817:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2931,7 +2931,7 @@ fn test_Float_f32_Euler_Approximate() {
 }
 
 #[test]
-fn test_Float_Default_Golden_Ratio() {
+fn test_float_default_golden_ratio() {
     let src = "1.618033988749895";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2948,7 +2948,7 @@ fn test_Float_Default_Golden_Ratio() {
 }
 
 #[test]
-fn test_Float_Default_Sqrt2() {
+fn test_float_default_sqrt2() {
     let src = "1.4142135623730951";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2965,7 +2965,7 @@ fn test_Float_Default_Sqrt2() {
 }
 
 #[test]
-fn test_Float_Default_Positive_Zero() {
+fn test_float_default_positive_zero() {
     let src = "0.0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2982,7 +2982,7 @@ fn test_Float_Default_Positive_Zero() {
 }
 
 #[test]
-fn test_Float_Default_Negative_Zero() {
+fn test_float_default_negative_zero() {
     let src = "-0.0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -2999,7 +2999,7 @@ fn test_Float_Default_Negative_Zero() {
 }
 
 #[test]
-fn test_Float_f32_Positive_Zero() {
+fn test_float_f32_positive_zero() {
     let src = "0.0:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3016,7 +3016,7 @@ fn test_Float_f32_Positive_Zero() {
 }
 
 #[test]
-fn test_Float_f32_Negative_Zero() {
+fn test_float_f32_negative_zero() {
     let src = "-0.0:f32";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3033,7 +3033,7 @@ fn test_Float_f32_Negative_Zero() {
 }
 
 #[test]
-fn test_Char_Simple_Letter_A() {
+fn test_char_simple_letter_uppercase_a() {
     let src = "'A'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3050,7 +3050,7 @@ fn test_Char_Simple_Letter_A() {
 }
 
 #[test]
-fn test_Char_Simple_Letter_a() {
+fn test_char_simple_letter_lowercase_a() {
     let src = "'a'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3067,7 +3067,7 @@ fn test_Char_Simple_Letter_a() {
 }
 
 #[test]
-fn test_Char_Simple_Letter_Z() {
+fn test_char_simple_letter_uppercase_z() {
     let src = "'Z'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3084,7 +3084,7 @@ fn test_Char_Simple_Letter_Z() {
 }
 
 #[test]
-fn test_Char_Simple_Letter_z() {
+fn test_char_simple_letter_lowercase_z() {
     let src = "'z'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3101,7 +3101,7 @@ fn test_Char_Simple_Letter_z() {
 }
 
 #[test]
-fn test_Char_Digit_0() {
+fn test_char_digit_0() {
     let src = "'0'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3118,7 +3118,7 @@ fn test_Char_Digit_0() {
 }
 
 #[test]
-fn test_Char_Digit_5() {
+fn test_char_digit_5() {
     let src = "'5'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3135,7 +3135,7 @@ fn test_Char_Digit_5() {
 }
 
 #[test]
-fn test_Char_Digit_9() {
+fn test_char_digit_9() {
     let src = "'9'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3152,7 +3152,7 @@ fn test_Char_Digit_9() {
 }
 
 #[test]
-fn test_Char_Space() {
+fn test_char_space() {
     let src = "' '";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3169,7 +3169,7 @@ fn test_Char_Space() {
 }
 
 #[test]
-fn test_Char_Exclamation() {
+fn test_char_exclamation() {
     let src = "'!'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3186,7 +3186,7 @@ fn test_Char_Exclamation() {
 }
 
 #[test]
-fn test_Char_Question_Mark() {
+fn test_char_question_mark() {
     let src = "'?'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3203,7 +3203,7 @@ fn test_Char_Question_Mark() {
 }
 
 #[test]
-fn test_Char_Period() {
+fn test_char_period() {
     let src = "'.'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3220,7 +3220,7 @@ fn test_Char_Period() {
 }
 
 #[test]
-fn test_Char_Comma() {
+fn test_char_comma() {
     let src = "','";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3237,7 +3237,7 @@ fn test_Char_Comma() {
 }
 
 #[test]
-fn test_Char_Semicolon() {
+fn test_char_semicolon() {
     let src = "';'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3254,7 +3254,7 @@ fn test_Char_Semicolon() {
 }
 
 #[test]
-fn test_Char_Colon() {
+fn test_char_colon() {
     let src = "':'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3271,7 +3271,7 @@ fn test_Char_Colon() {
 }
 
 #[test]
-fn test_Char_Plus() {
+fn test_char_plus() {
     let src = "'+'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3288,7 +3288,7 @@ fn test_Char_Plus() {
 }
 
 #[test]
-fn test_Char_Minus() {
+fn test_char_minus() {
     let src = "'-'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3305,7 +3305,7 @@ fn test_Char_Minus() {
 }
 
 #[test]
-fn test_Char_Asterisk() {
+fn test_char_asterisk() {
     let src = "'*'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3322,7 +3322,7 @@ fn test_Char_Asterisk() {
 }
 
 #[test]
-fn test_Char_Slash() {
+fn test_char_slash() {
     let src = "'/'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3339,7 +3339,7 @@ fn test_Char_Slash() {
 }
 
 #[test]
-fn test_Char_Equals() {
+fn test_char_equals() {
     let src = "'='";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3356,7 +3356,7 @@ fn test_Char_Equals() {
 }
 
 #[test]
-fn test_Char_Less_Than() {
+fn test_char_less_than() {
     let src = "'<'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3373,7 +3373,7 @@ fn test_Char_Less_Than() {
 }
 
 #[test]
-fn test_Char_Greater_Than() {
+fn test_char_greater_than() {
     let src = "'>'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3390,7 +3390,7 @@ fn test_Char_Greater_Than() {
 }
 
 #[test]
-fn test_Char_Left_Paren() {
+fn test_char_left_paren() {
     let src = "'('";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3407,7 +3407,7 @@ fn test_Char_Left_Paren() {
 }
 
 #[test]
-fn test_Char_Right_Paren() {
+fn test_char_right_paren() {
     let src = "')'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3424,7 +3424,7 @@ fn test_Char_Right_Paren() {
 }
 
 #[test]
-fn test_Char_Left_Bracket() {
+fn test_char_left_bracket() {
     let src = "'['";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3441,7 +3441,7 @@ fn test_Char_Left_Bracket() {
 }
 
 #[test]
-fn test_Char_Right_Bracket() {
+fn test_char_right_bracket() {
     let src = "']'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3458,7 +3458,7 @@ fn test_Char_Right_Bracket() {
 }
 
 #[test]
-fn test_Char_Left_Brace() {
+fn test_char_left_brace() {
     let src = "'{'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3475,7 +3475,7 @@ fn test_Char_Left_Brace() {
 }
 
 #[test]
-fn test_Char_Right_Brace() {
+fn test_char_right_brace() {
     let src = "'}'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3492,58 +3492,7 @@ fn test_Char_Right_Brace() {
 }
 
 #[test]
-fn test_Char_Escape_Tab() {
-    let src = "'\\\\t'";
-    let mut lexer = sls::lexer::Lexer::new(src);
-    let mut got = vec![];
-    loop {
-        let t = lexer.next_token();
-        if t.ttype == sls::lexer::TokenType::Eof { break; }
-        got.push(t);
-    }
-
-    assert_eq!(got.len(), 1usize, "token count mismatch");
-    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
-        assert!(got[0].numeric.is_some(), "expected numeric char code");
-        assert_eq!(got[0].numeric.unwrap(), 9);
-}
-
-#[test]
-fn test_Char_Escape_Backslash() {
-    let src = "'\\\\\\\\'";
-    let mut lexer = sls::lexer::Lexer::new(src);
-    let mut got = vec![];
-    loop {
-        let t = lexer.next_token();
-        if t.ttype == sls::lexer::TokenType::Eof { break; }
-        got.push(t);
-    }
-
-    assert_eq!(got.len(), 1usize, "token count mismatch");
-    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
-        assert!(got[0].numeric.is_some(), "expected numeric char code");
-        assert_eq!(got[0].numeric.unwrap(), 92);
-}
-
-#[test]
-fn test_Char_Escape_Null_character() {
-    let src = "'\\\\0'";
-    let mut lexer = sls::lexer::Lexer::new(src);
-    let mut got = vec![];
-    loop {
-        let t = lexer.next_token();
-        if t.ttype == sls::lexer::TokenType::Eof { break; }
-        got.push(t);
-    }
-
-    assert_eq!(got.len(), 1usize, "token count mismatch");
-    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
-        assert!(got[0].numeric.is_some(), "expected numeric char code");
-        assert_eq!(got[0].numeric.unwrap(), 0);
-}
-
-#[test]
-fn test_Char_Escape_Single_quote() {
+fn test_char_escape_single_quote() {
     let src = "'\\\\''";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3560,24 +3509,7 @@ fn test_Char_Escape_Single_quote() {
 }
 
 #[test]
-fn test_Char_Escape_Carriage_return() {
-    let src = "'\\\\r'";
-    let mut lexer = sls::lexer::Lexer::new(src);
-    let mut got = vec![];
-    loop {
-        let t = lexer.next_token();
-        if t.ttype == sls::lexer::TokenType::Eof { break; }
-        got.push(t);
-    }
-
-    assert_eq!(got.len(), 1usize, "token count mismatch");
-    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
-        assert!(got[0].numeric.is_some(), "expected numeric char code");
-        assert_eq!(got[0].numeric.unwrap(), 13);
-}
-
-#[test]
-fn test_Char_Escape_Newline() {
+fn test_char_escape_newline() {
     let src = "'\\\\n'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3594,7 +3526,75 @@ fn test_Char_Escape_Newline() {
 }
 
 #[test]
-fn test_Char_With_Leading_Whitespace() {
+fn test_char_escape_null_character() {
+    let src = "'\\\\0'";
+    let mut lexer = sls::lexer::Lexer::new(src);
+    let mut got = vec![];
+    loop {
+        let t = lexer.next_token();
+        if t.ttype == sls::lexer::TokenType::Eof { break; }
+        got.push(t);
+    }
+
+    assert_eq!(got.len(), 1usize, "token count mismatch");
+    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
+        assert!(got[0].numeric.is_some(), "expected numeric char code");
+        assert_eq!(got[0].numeric.unwrap(), 0);
+}
+
+#[test]
+fn test_char_escape_backslash() {
+    let src = "'\\\\\\\\'";
+    let mut lexer = sls::lexer::Lexer::new(src);
+    let mut got = vec![];
+    loop {
+        let t = lexer.next_token();
+        if t.ttype == sls::lexer::TokenType::Eof { break; }
+        got.push(t);
+    }
+
+    assert_eq!(got.len(), 1usize, "token count mismatch");
+    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
+        assert!(got[0].numeric.is_some(), "expected numeric char code");
+        assert_eq!(got[0].numeric.unwrap(), 92);
+}
+
+#[test]
+fn test_char_escape_tab() {
+    let src = "'\\\\t'";
+    let mut lexer = sls::lexer::Lexer::new(src);
+    let mut got = vec![];
+    loop {
+        let t = lexer.next_token();
+        if t.ttype == sls::lexer::TokenType::Eof { break; }
+        got.push(t);
+    }
+
+    assert_eq!(got.len(), 1usize, "token count mismatch");
+    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
+        assert!(got[0].numeric.is_some(), "expected numeric char code");
+        assert_eq!(got[0].numeric.unwrap(), 9);
+}
+
+#[test]
+fn test_char_escape_carriage_return() {
+    let src = "'\\\\r'";
+    let mut lexer = sls::lexer::Lexer::new(src);
+    let mut got = vec![];
+    loop {
+        let t = lexer.next_token();
+        if t.ttype == sls::lexer::TokenType::Eof { break; }
+        got.push(t);
+    }
+
+    assert_eq!(got.len(), 1usize, "token count mismatch");
+    assert_eq!(got[0].ttype, sls::lexer::TokenType::Int);
+        assert!(got[0].numeric.is_some(), "expected numeric char code");
+        assert_eq!(got[0].numeric.unwrap(), 13);
+}
+
+#[test]
+fn test_char_with_leading_whitespace() {
     let src = "  'A'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3611,7 +3611,7 @@ fn test_Char_With_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Char_With_Trailing_Whitespace() {
+fn test_char_with_trailing_whitespace() {
     let src = "'A'  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3628,7 +3628,7 @@ fn test_Char_With_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Char_With_Both_Whitespace() {
+fn test_char_with_both_whitespace() {
     let src = "  'A'  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3645,7 +3645,7 @@ fn test_Char_With_Both_Whitespace() {
 }
 
 #[test]
-fn test_Char_Tab_Before() {
+fn test_char_tab_before() {
     let src = "\\t'B'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3662,7 +3662,7 @@ fn test_Char_Tab_Before() {
 }
 
 #[test]
-fn test_Char_Newline_Before() {
+fn test_char_newline_before() {
     let src = "\\n'C'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3679,7 +3679,7 @@ fn test_Char_Newline_Before() {
 }
 
 #[test]
-fn test_Char_Empty_Literal() {
+fn test_char_empty_literal() {
     let src = "''";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3694,7 +3694,7 @@ fn test_Char_Empty_Literal() {
 }
 
 #[test]
-fn test_Char_Multiple_Characters() {
+fn test_char_multiple_characters() {
     let src = "'AB'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3709,7 +3709,7 @@ fn test_Char_Multiple_Characters() {
 }
 
 #[test]
-fn test_Char_Unclosed_Quote() {
+fn test_char_unclosed_quote() {
     let src = "'A";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3724,7 +3724,7 @@ fn test_Char_Unclosed_Quote() {
 }
 
 #[test]
-fn test_Char_Unescaped_Newline() {
+fn test_char_unescaped_newline() {
     let src = "'\\n'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3739,7 +3739,7 @@ fn test_Char_Unescaped_Newline() {
 }
 
 #[test]
-fn test_Char_Invalid_Escape() {
+fn test_char_invalid_escape() {
     let src = "'\\\\q'";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3754,7 +3754,7 @@ fn test_Char_Invalid_Escape() {
 }
 
 #[test]
-fn test_Identifier_Simple_Lowercase() {
+fn test_identifier_simple_lowercase() {
     let src = "hello";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3770,7 +3770,7 @@ fn test_Identifier_Simple_Lowercase() {
 }
 
 #[test]
-fn test_Identifier_Simple_Uppercase() {
+fn test_identifier_simple_uppercase() {
     let src = "HELLO";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3786,7 +3786,7 @@ fn test_Identifier_Simple_Uppercase() {
 }
 
 #[test]
-fn test_Identifier_Mixed_Case() {
+fn test_identifier_mixed_case() {
     let src = "HelloWorld";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3802,7 +3802,7 @@ fn test_Identifier_Mixed_Case() {
 }
 
 #[test]
-fn test_Identifier_Single_Letter() {
+fn test_identifier_single_letter() {
     let src = "x";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3818,7 +3818,7 @@ fn test_Identifier_Single_Letter() {
 }
 
 #[test]
-fn test_Identifier_Single_Letter_Upper() {
+fn test_identifier_single_letter_upper() {
     let src = "X";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3834,7 +3834,7 @@ fn test_Identifier_Single_Letter_Upper() {
 }
 
 #[test]
-fn test_Identifier_With_Numbers() {
+fn test_identifier_with_numbers() {
     let src = "var123";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3850,7 +3850,7 @@ fn test_Identifier_With_Numbers() {
 }
 
 #[test]
-fn test_Identifier_Numbers_End() {
+fn test_identifier_numbers_end() {
     let src = "myVar2";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3866,7 +3866,7 @@ fn test_Identifier_Numbers_End() {
 }
 
 #[test]
-fn test_Identifier_Mixed_Numbers() {
+fn test_identifier_mixed_numbers() {
     let src = "a1b2c3";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3882,7 +3882,7 @@ fn test_Identifier_Mixed_Numbers() {
 }
 
 #[test]
-fn test_Identifier_With_Underscore() {
+fn test_identifier_with_underscore() {
     let src = "hello_world";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3898,7 +3898,7 @@ fn test_Identifier_With_Underscore() {
 }
 
 #[test]
-fn test_Identifier_Leading_Underscore() {
+fn test_identifier_leading_underscore() {
     let src = "_private";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3914,7 +3914,7 @@ fn test_Identifier_Leading_Underscore() {
 }
 
 #[test]
-fn test_Identifier_Multiple_Underscores() {
+fn test_identifier_multiple_underscores() {
     let src = "my_long_var_name";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3930,7 +3930,7 @@ fn test_Identifier_Multiple_Underscores() {
 }
 
 #[test]
-fn test_Identifier_Double_Underscore() {
+fn test_identifier_double_underscore() {
     let src = "my__var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3946,7 +3946,7 @@ fn test_Identifier_Double_Underscore() {
 }
 
 #[test]
-fn test_Identifier_Trailing_Underscore() {
+fn test_identifier_trailing_underscore() {
     let src = "var_";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3962,7 +3962,7 @@ fn test_Identifier_Trailing_Underscore() {
 }
 
 #[test]
-fn test_Identifier_Only_Underscores() {
+fn test_identifier_only_underscores() {
     let src = "___";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3978,7 +3978,7 @@ fn test_Identifier_Only_Underscores() {
 }
 
 #[test]
-fn test_Identifier_Snake_Case() {
+fn test_identifier_snake_case() {
     let src = "my_variable_name";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -3994,7 +3994,7 @@ fn test_Identifier_Snake_Case() {
 }
 
 #[test]
-fn test_Identifier_Camel_Case() {
+fn test_identifier_camel_case() {
     let src = "myVariableName";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4010,7 +4010,7 @@ fn test_Identifier_Camel_Case() {
 }
 
 #[test]
-fn test_Identifier_Pascal_Case() {
+fn test_identifier_pascal_case() {
     let src = "MyClassName";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4026,7 +4026,7 @@ fn test_Identifier_Pascal_Case() {
 }
 
 #[test]
-fn test_Identifier_All_Caps() {
+fn test_identifier_all_caps() {
     let src = "MY_CONSTANT";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4042,7 +4042,7 @@ fn test_Identifier_All_Caps() {
 }
 
 #[test]
-fn test_Identifier_With_Dash() {
+fn test_identifier_with_dash() {
     let src = "my-var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4058,7 +4058,7 @@ fn test_Identifier_With_Dash() {
 }
 
 #[test]
-fn test_Identifier_Literal_Simple() {
+fn test_identifier_literal_simple() {
     let src = "::hello";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4074,7 +4074,7 @@ fn test_Identifier_Literal_Simple() {
 }
 
 #[test]
-fn test_Identifier_Literal_Uppercase() {
+fn test_identifier_literal_uppercase() {
     let src = "::Point";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4090,7 +4090,7 @@ fn test_Identifier_Literal_Uppercase() {
 }
 
 #[test]
-fn test_Identifier_Literal_Snake_Case() {
+fn test_identifier_literal_snake_case() {
     let src = "::my_var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4106,7 +4106,7 @@ fn test_Identifier_Literal_Snake_Case() {
 }
 
 #[test]
-fn test_Identifier_Literal_Type_i64() {
+fn test_identifier_literal_type_i64() {
     let src = "::i64";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4122,7 +4122,7 @@ fn test_Identifier_Literal_Type_i64() {
 }
 
 #[test]
-fn test_Identifier_Literal_Type_String() {
+fn test_identifier_literal_type_string() {
     let src = "::String";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4138,7 +4138,7 @@ fn test_Identifier_Literal_Type_String() {
 }
 
 #[test]
-fn test_Identifier_Literal_Type_Point() {
+fn test_identifier_literal_type_point() {
     let src = "::Point";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4154,7 +4154,7 @@ fn test_Identifier_Literal_Type_Point() {
 }
 
 #[test]
-fn test_Identifier_Literal_Trait_Addable() {
+fn test_identifier_literal_trait_addable() {
     let src = "::Addable";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4170,7 +4170,7 @@ fn test_Identifier_Literal_Trait_Addable() {
 }
 
 #[test]
-fn test_Identifier_Literal_Trait_Drawable() {
+fn test_identifier_literal_trait_drawable() {
     let src = "::Drawable";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4186,7 +4186,7 @@ fn test_Identifier_Literal_Trait_Drawable() {
 }
 
 #[test]
-fn test_Identifier_Literal_Field_x() {
+fn test_identifier_literal_field_x() {
     let src = "::x";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4202,7 +4202,7 @@ fn test_Identifier_Literal_Field_x() {
 }
 
 #[test]
-fn test_Identifier_Literal_Field_width() {
+fn test_identifier_literal_field_width() {
     let src = "::width";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4218,7 +4218,7 @@ fn test_Identifier_Literal_Field_width() {
 }
 
 #[test]
-fn test_Identifier_Literal_With_Underscore() {
+fn test_identifier_literal_with_underscore() {
     let src = "::_private";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4234,7 +4234,7 @@ fn test_Identifier_Literal_With_Underscore() {
 }
 
 #[test]
-fn test_Identifier_Literal_Multiple_Underscores() {
+fn test_identifier_literal_multiple_underscores() {
     let src = "::my_long_name";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4250,7 +4250,7 @@ fn test_Identifier_Literal_Multiple_Underscores() {
 }
 
 #[test]
-fn test_Identifier_Literal_With_Numbers() {
+fn test_identifier_literal_with_numbers() {
     let src = "::var123";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4266,7 +4266,7 @@ fn test_Identifier_Literal_With_Numbers() {
 }
 
 #[test]
-fn test_Identifier_Leading_Whitespace() {
+fn test_identifier_leading_whitespace() {
     let src = "  hello";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4282,7 +4282,7 @@ fn test_Identifier_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Trailing_Whitespace() {
+fn test_identifier_trailing_whitespace() {
     let src = "hello  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4298,7 +4298,7 @@ fn test_Identifier_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Both_Whitespace() {
+fn test_identifier_both_whitespace() {
     let src = "  hello  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4314,7 +4314,7 @@ fn test_Identifier_Both_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Tab_Before() {
+fn test_identifier_tab_before() {
     let src = "\\thello";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4330,7 +4330,7 @@ fn test_Identifier_Tab_Before() {
 }
 
 #[test]
-fn test_Identifier_Literal_Leading_Whitespace() {
+fn test_identifier_literal_leading_whitespace() {
     let src = "  ::hello";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4346,7 +4346,7 @@ fn test_Identifier_Literal_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Literal_Trailing_Whitespace() {
+fn test_identifier_literal_trailing_whitespace() {
     let src = "::hello  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4362,7 +4362,7 @@ fn test_Identifier_Literal_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Literal_Both_Whitespace() {
+fn test_identifier_literal_both_whitespace() {
     let src = "  ::hello  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4378,7 +4378,7 @@ fn test_Identifier_Literal_Both_Whitespace() {
 }
 
 #[test]
-fn test_Identifier_Moderate_Length() {
+fn test_identifier_moderate_length() {
     let src = "thisIsAReasonablyLongVariableName";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4394,7 +4394,7 @@ fn test_Identifier_Moderate_Length() {
 }
 
 #[test]
-fn test_Identifier_Very_Long() {
+fn test_identifier_very_long() {
     let src = "this_is_a_very_long_identifier_name_that_someone_might_use_for_some_reason";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4410,7 +4410,7 @@ fn test_Identifier_Very_Long() {
 }
 
 #[test]
-fn test_Identifier_Long_With_Numbers() {
+fn test_identifier_long_with_numbers() {
     let src = "variable_with_many_numbers_123_456_789_000";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4426,7 +4426,7 @@ fn test_Identifier_Long_With_Numbers() {
 }
 
 #[test]
-fn test_Identifier_Starting_With_Number() {
+fn test_identifier_starting_with_number() {
     let src = "123abc";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4441,7 +4441,7 @@ fn test_Identifier_Starting_With_Number() {
 }
 
 #[test]
-fn test_Identifier_With_Octothorpe() {
+fn test_identifier_with_octothorpe() {
     let src = "my#var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4457,7 +4457,7 @@ fn test_Identifier_With_Octothorpe() {
 }
 
 #[test]
-fn test_Identifier_With_Colon() {
+fn test_identifier_with_colon() {
     let src = "my:var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4472,7 +4472,7 @@ fn test_Identifier_With_Colon() {
 }
 
 #[test]
-fn test_Identifier_Double_Colon_Inside() {
+fn test_identifier_double_colon_inside() {
     let src = "my::var";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4487,7 +4487,7 @@ fn test_Identifier_Double_Colon_Inside() {
 }
 
 #[test]
-fn test_Identifier_Only_Numbers() {
+fn test_identifier_only_numbers() {
     let src = "123";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4504,7 +4504,7 @@ fn test_Identifier_Only_Numbers() {
 }
 
 #[test]
-fn test_Identifier_Literal_Empty() {
+fn test_identifier_literal_empty() {
     let src = "::";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4519,7 +4519,7 @@ fn test_Identifier_Literal_Empty() {
 }
 
 #[test]
-fn test_Identifier_Case_Lower() {
+fn test_identifier_case_lower() {
     let src = "variable";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4535,7 +4535,7 @@ fn test_Identifier_Case_Lower() {
 }
 
 #[test]
-fn test_Identifier_Case_Upper() {
+fn test_identifier_case_upper() {
     let src = "VARIABLE";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4551,7 +4551,7 @@ fn test_Identifier_Case_Upper() {
 }
 
 #[test]
-fn test_Identifier_Case_Mixed() {
+fn test_identifier_case_mixed() {
     let src = "Variable";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4567,7 +4567,7 @@ fn test_Identifier_Case_Mixed() {
 }
 
 #[test]
-fn test_Identifier_Case_Camel() {
+fn test_identifier_case_camel() {
     let src = "variableName";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4583,7 +4583,7 @@ fn test_Identifier_Case_Camel() {
 }
 
 #[test]
-fn test_Identifier_Case_Pascal() {
+fn test_identifier_case_pascal() {
     let src = "VariableName";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4599,7 +4599,7 @@ fn test_Identifier_Case_Pascal() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_if() {
+fn test_identifier_reserved_word_if() {
     let src = "if";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4615,7 +4615,7 @@ fn test_Identifier_Reserved_Word_if() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_while() {
+fn test_identifier_reserved_word_while() {
     let src = "while";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4631,7 +4631,7 @@ fn test_Identifier_Reserved_Word_while() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_for() {
+fn test_identifier_reserved_word_for() {
     let src = "for";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4647,7 +4647,7 @@ fn test_Identifier_Reserved_Word_for() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_match() {
+fn test_identifier_reserved_word_match() {
     let src = "match";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4663,7 +4663,7 @@ fn test_Identifier_Reserved_Word_match() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_break() {
+fn test_identifier_reserved_word_break() {
     let src = "break";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4679,7 +4679,7 @@ fn test_Identifier_Reserved_Word_break() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_continue() {
+fn test_identifier_reserved_word_continue() {
     let src = "continue";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4695,7 +4695,7 @@ fn test_Identifier_Reserved_Word_continue() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_fn() {
+fn test_identifier_reserved_word_fn() {
     let src = "fn";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4711,7 +4711,7 @@ fn test_Identifier_Reserved_Word_fn() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_struct() {
+fn test_identifier_reserved_word_struct() {
     let src = "struct";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4727,7 +4727,7 @@ fn test_Identifier_Reserved_Word_struct() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_union() {
+fn test_identifier_reserved_word_union() {
     let src = "union";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4743,7 +4743,7 @@ fn test_Identifier_Reserved_Word_union() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_enum() {
+fn test_identifier_reserved_word_enum() {
     let src = "enum";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4759,7 +4759,7 @@ fn test_Identifier_Reserved_Word_enum() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_trait() {
+fn test_identifier_reserved_word_trait() {
     let src = "trait";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4775,7 +4775,7 @@ fn test_Identifier_Reserved_Word_trait() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_impl() {
+fn test_identifier_reserved_word_impl() {
     let src = "impl";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4791,7 +4791,7 @@ fn test_Identifier_Reserved_Word_impl() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_inher() {
+fn test_identifier_reserved_word_inher() {
     let src = "inher";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4807,7 +4807,7 @@ fn test_Identifier_Reserved_Word_inher() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_dup() {
+fn test_identifier_reserved_word_dup() {
     let src = "dup";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4823,7 +4823,7 @@ fn test_Identifier_Reserved_Word_dup() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_drop() {
+fn test_identifier_reserved_word_drop() {
     let src = "drop";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4839,7 +4839,7 @@ fn test_Identifier_Reserved_Word_drop() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_swap() {
+fn test_identifier_reserved_word_swap() {
     let src = "swap";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4855,7 +4855,7 @@ fn test_Identifier_Reserved_Word_swap() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_over() {
+fn test_identifier_reserved_word_over() {
     let src = "over";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4871,7 +4871,7 @@ fn test_Identifier_Reserved_Word_over() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_rot() {
+fn test_identifier_reserved_word_rot() {
     let src = "rot";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4887,7 +4887,7 @@ fn test_Identifier_Reserved_Word_rot() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_pick() {
+fn test_identifier_reserved_word_pick() {
     let src = "pick";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4903,7 +4903,7 @@ fn test_Identifier_Reserved_Word_pick() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_roll() {
+fn test_identifier_reserved_word_roll() {
     let src = "roll";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4919,7 +4919,7 @@ fn test_Identifier_Reserved_Word_roll() {
 }
 
 #[test]
-fn test_Identifier_Reserved_Word_depth() {
+fn test_identifier_reserved_word_depth() {
     let src = "depth";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4935,7 +4935,7 @@ fn test_Identifier_Reserved_Word_depth() {
 }
 
 #[test]
-fn test_Bool_True() {
+fn test_bool_true() {
     let src = "true";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4951,7 +4951,7 @@ fn test_Bool_True() {
 }
 
 #[test]
-fn test_Bool_False() {
+fn test_bool_false() {
     let src = "false";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4967,7 +4967,7 @@ fn test_Bool_False() {
 }
 
 #[test]
-fn test_Bool_True_Leading_Whitespace() {
+fn test_bool_true_leading_whitespace() {
     let src = "  true";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4983,7 +4983,7 @@ fn test_Bool_True_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Bool_True_Trailing_Whitespace() {
+fn test_bool_true_trailing_whitespace() {
     let src = "true  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -4999,7 +4999,7 @@ fn test_Bool_True_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Bool_True_Both_Whitespace() {
+fn test_bool_true_both_whitespace() {
     let src = "  true  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5015,7 +5015,7 @@ fn test_Bool_True_Both_Whitespace() {
 }
 
 #[test]
-fn test_Bool_True_Tab_Before() {
+fn test_bool_true_tab_before() {
     let src = "\\ttrue";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5031,7 +5031,7 @@ fn test_Bool_True_Tab_Before() {
 }
 
 #[test]
-fn test_Bool_False_Leading_Whitespace() {
+fn test_bool_false_leading_whitespace() {
     let src = "  false";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5047,7 +5047,7 @@ fn test_Bool_False_Leading_Whitespace() {
 }
 
 #[test]
-fn test_Bool_False_Trailing_Whitespace() {
+fn test_bool_false_trailing_whitespace() {
     let src = "false  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5063,7 +5063,7 @@ fn test_Bool_False_Trailing_Whitespace() {
 }
 
 #[test]
-fn test_Bool_False_Both_Whitespace() {
+fn test_bool_false_both_whitespace() {
     let src = "  false  ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5079,7 +5079,7 @@ fn test_Bool_False_Both_Whitespace() {
 }
 
 #[test]
-fn test_Bool_False_Tab_Before() {
+fn test_bool_false_tab_before() {
     let src = "\\tfalse";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5095,7 +5095,7 @@ fn test_Bool_False_Tab_Before() {
 }
 
 #[test]
-fn test_Bool_True_Capitalized() {
+fn test_bool_true_capitalized() {
     let src = "True";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5111,7 +5111,7 @@ fn test_Bool_True_Capitalized() {
 }
 
 #[test]
-fn test_Bool_False_Capitalized() {
+fn test_bool_false_capitalized() {
     let src = "False";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5127,7 +5127,7 @@ fn test_Bool_False_Capitalized() {
 }
 
 #[test]
-fn test_Bool_True_All_Caps() {
+fn test_bool_true_all_caps() {
     let src = "TRUE";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5143,7 +5143,7 @@ fn test_Bool_True_All_Caps() {
 }
 
 #[test]
-fn test_Bool_False_All_Caps() {
+fn test_bool_false_all_caps() {
     let src = "FALSE";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5159,7 +5159,7 @@ fn test_Bool_False_All_Caps() {
 }
 
 #[test]
-fn test_Bool_True_Mixed_Case() {
+fn test_bool_true_mixed_case() {
     let src = "tRuE";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5175,7 +5175,7 @@ fn test_Bool_True_Mixed_Case() {
 }
 
 #[test]
-fn test_Bool_False_Mixed_Case() {
+fn test_bool_false_mixed_case() {
     let src = "fAlSe";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5191,7 +5191,7 @@ fn test_Bool_False_Mixed_Case() {
 }
 
 #[test]
-fn test_Bool_Numeric_1() {
+fn test_bool_numeric_1() {
     let src = "1";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5208,7 +5208,7 @@ fn test_Bool_Numeric_1() {
 }
 
 #[test]
-fn test_Bool_Numeric_0() {
+fn test_bool_numeric_0() {
     let src = "0";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5225,7 +5225,7 @@ fn test_Bool_Numeric_0() {
 }
 
 #[test]
-fn test_Bool_Yes() {
+fn test_bool_yes() {
     let src = "yes";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5241,7 +5241,7 @@ fn test_Bool_Yes() {
 }
 
 #[test]
-fn test_Bool_No() {
+fn test_bool_no() {
     let src = "no";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5257,7 +5257,7 @@ fn test_Bool_No() {
 }
 
 #[test]
-fn test_Bool_Typo_Ture() {
+fn test_bool_typo_ture() {
     let src = "ture";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5273,7 +5273,7 @@ fn test_Bool_Typo_Ture() {
 }
 
 #[test]
-fn test_Bool_Typo_Flase() {
+fn test_bool_typo_flase() {
     let src = "flase";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5289,7 +5289,7 @@ fn test_Bool_Typo_Flase() {
 }
 
 #[test]
-fn test_Bool_Multiple_True_False() {
+fn test_bool_multiple_true_false() {
     let src = "true false";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5307,7 +5307,7 @@ fn test_Bool_Multiple_True_False() {
 }
 
 #[test]
-fn test_Bool_Multiple_Same() {
+fn test_bool_multiple_same() {
     let src = "true true";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5325,7 +5325,7 @@ fn test_Bool_Multiple_Same() {
 }
 
 #[test]
-fn test_Bool_Three_Values() {
+fn test_bool_three_values() {
     let src = "true false true";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5345,7 +5345,7 @@ fn test_Bool_Three_Values() {
 }
 
 #[test]
-fn test_TokenString_Empty() {
+fn test_tokenstring_empty() {
     let src = "{ }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5359,12 +5359,11 @@ fn test_TokenString_Empty() {
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
-        assert!(!got.is_empty(), "no tokens produced");
         assert!(!got[0].lexeme.is_empty());
 }
 
 #[test]
-fn test_TokenString_Single_Integer() {
+fn test_tokenstring_single_integer() {
     let src = "{ 42 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5374,7 +5373,7 @@ fn test_TokenString_Single_Integer() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5382,7 +5381,7 @@ fn test_TokenString_Single_Integer() {
 }
 
 #[test]
-fn test_TokenString_Single_Identifier() {
+fn test_tokenstring_single_identifier() {
     let src = "{ dup }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5392,7 +5391,7 @@ fn test_TokenString_Single_Identifier() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5400,7 +5399,7 @@ fn test_TokenString_Single_Identifier() {
 }
 
 #[test]
-fn test_TokenString_Two_Integers() {
+fn test_tokenstring_two_integers() {
     let src = "{ 2 3 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5410,7 +5409,7 @@ fn test_TokenString_Two_Integers() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5418,7 +5417,7 @@ fn test_TokenString_Two_Integers() {
 }
 
 #[test]
-fn test_TokenString_Simple_Expression() {
+fn test_tokenstring_simple_expression() {
     let src = "{ 2 3 + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5428,7 +5427,7 @@ fn test_TokenString_Simple_Expression() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5436,7 +5435,7 @@ fn test_TokenString_Simple_Expression() {
 }
 
 #[test]
-fn test_TokenString_Stack_Ops() {
+fn test_tokenstring_stack_ops() {
     let src = "{ dup * }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5446,7 +5445,7 @@ fn test_TokenString_Stack_Ops() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5454,7 +5453,7 @@ fn test_TokenString_Stack_Ops() {
 }
 
 #[test]
-fn test_TokenString_Integer_Literals() {
+fn test_tokenstring_integer_literals() {
     let src = "{ 0 42 -10 1000 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5464,7 +5463,7 @@ fn test_TokenString_Integer_Literals() {
         got.push(t);
     }
 
-    assert!(!got.is_empty(), "no tokens produced");
+    assert_eq!(got.len(), 1usize, "token count mismatch");
     // token_string check not implemented; received token: {:#?}
         // TODO: implement nested expectations
         // for now just assert we got an Ident or similar
@@ -5472,7 +5471,7 @@ fn test_TokenString_Integer_Literals() {
 }
 
 #[test]
-fn test_TokenString_Float_Literals() {
+fn test_tokenstring_float_literals() {
     let src = "{ 3.14 -2.5 0.0 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5490,7 +5489,7 @@ fn test_TokenString_Float_Literals() {
 }
 
 #[test]
-fn test_TokenString_Char_Literal() {
+fn test_tokenstring_char_literal() {
     let src = "{ 'A' }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5508,7 +5507,7 @@ fn test_TokenString_Char_Literal() {
 }
 
 #[test]
-fn test_TokenString_Boolean_Literals() {
+fn test_tokenstring_boolean_literals() {
     let src = "{ true false }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5526,7 +5525,7 @@ fn test_TokenString_Boolean_Literals() {
 }
 
 #[test]
-fn test_TokenString_Multiple_Identifiers() {
+fn test_tokenstring_multiple_identifiers() {
     let src = "{ dup swap over }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5544,7 +5543,7 @@ fn test_TokenString_Multiple_Identifiers() {
 }
 
 #[test]
-fn test_TokenString_Identifier_Literals() {
+fn test_tokenstring_identifier_literals() {
     let src = "{ ::x ::y }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5562,7 +5561,7 @@ fn test_TokenString_Identifier_Literals() {
 }
 
 #[test]
-fn test_TokenString_Mixed_Identifiers() {
+fn test_tokenstring_mixed_identifiers() {
     let src = "{ ::Point get x swap }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5580,7 +5579,7 @@ fn test_TokenString_Mixed_Identifiers() {
 }
 
 #[test]
-fn test_TokenString_Nested_Single() {
+fn test_tokenstring_nested_single() {
     let src = "{ { 2 3 + } }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5598,7 +5597,7 @@ fn test_TokenString_Nested_Single() {
 }
 
 #[test]
-fn test_TokenString_Nested_With_Others() {
+fn test_tokenstring_nested_with_others() {
     let src = "{ x { dup * } }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5616,7 +5615,7 @@ fn test_TokenString_Nested_With_Others() {
 }
 
 #[test]
-fn test_TokenString_Multiple_Nested() {
+fn test_tokenstring_multiple_nested() {
     let src = "{ { 2 3 + } { 4 5 * } }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5634,7 +5633,7 @@ fn test_TokenString_Multiple_Nested() {
 }
 
 #[test]
-fn test_TokenString_Double_Nested() {
+fn test_tokenstring_double_nested() {
     let src = "{ { { 42 } } }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5652,7 +5651,7 @@ fn test_TokenString_Double_Nested() {
 }
 
 #[test]
-fn test_TokenString_Complex_Nesting() {
+fn test_tokenstring_complex_nesting() {
     let src = "{ 1 { 2 { 3 } 4 } 5 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5670,7 +5669,7 @@ fn test_TokenString_Complex_Nesting() {
 }
 
 #[test]
-fn test_TokenString_No_Whitespace() {
+fn test_tokenstring_no_whitespace() {
     let src = "{2 3 +}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5688,7 +5687,7 @@ fn test_TokenString_No_Whitespace() {
 }
 
 #[test]
-fn test_TokenString_Extra_Whitespace() {
+fn test_tokenstring_extra_whitespace() {
     let src = "{   2    3     +   }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5706,7 +5705,7 @@ fn test_TokenString_Extra_Whitespace() {
 }
 
 #[test]
-fn test_TokenString_Leading_Whitespace_Outside() {
+fn test_tokenstring_leading_whitespace_outside() {
     let src = "   { 2 3 + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5724,7 +5723,7 @@ fn test_TokenString_Leading_Whitespace_Outside() {
 }
 
 #[test]
-fn test_TokenString_Trailing_Whitespace_Outside() {
+fn test_tokenstring_trailing_whitespace_outside() {
     let src = "{ 2 3 + }   ";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5742,7 +5741,7 @@ fn test_TokenString_Trailing_Whitespace_Outside() {
 }
 
 #[test]
-fn test_TokenString_With_Tabs() {
+fn test_tokenstring_with_tabs() {
     let src = "{\\t2\\t3\\t+\\t}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5760,7 +5759,7 @@ fn test_TokenString_With_Tabs() {
 }
 
 #[test]
-fn test_TokenString_Multiline_Simple() {
+fn test_tokenstring_multiline_simple() {
     let src = "{\\n    2 3 +\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5778,7 +5777,7 @@ fn test_TokenString_Multiline_Simple() {
 }
 
 #[test]
-fn test_TokenString_Multiline_Multiple() {
+fn test_tokenstring_multiline_multiple() {
     let src = "{\\n    dup\\n    *\\n    2\\n    +\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5796,7 +5795,7 @@ fn test_TokenString_Multiline_Multiple() {
 }
 
 #[test]
-fn test_TokenString_Mixed_Line_Breaks() {
+fn test_tokenstring_mixed_line_breaks() {
     let src = "{ 1 2\\n3 4\\n\\n5 6 }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5814,7 +5813,7 @@ fn test_TokenString_Mixed_Line_Breaks() {
 }
 
 #[test]
-fn test_TokenString_Indented_Multiline() {
+fn test_tokenstring_indented_multiline() {
     let src = "{\\n    dup 0 >\\n        { }\\n        { 0 swap - }\\n    if\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5832,7 +5831,7 @@ fn test_TokenString_Indented_Multiline() {
 }
 
 #[test]
-fn test_TokenString_Comment_End_Of_Line() {
+fn test_tokenstring_comment_end_of_line() {
     let src = "{ 2 3 + // add them\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5850,7 +5849,7 @@ fn test_TokenString_Comment_End_Of_Line() {
 }
 
 #[test]
-fn test_TokenString_Multiple_Comments() {
+fn test_tokenstring_multiple_comments() {
     let src = "{ 2 // first\\n3 // second\\n+ // add\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5868,7 +5867,7 @@ fn test_TokenString_Multiple_Comments() {
 }
 
 #[test]
-fn test_TokenString_Comment_Own_Line() {
+fn test_tokenstring_comment_own_line() {
     let src = "{\\n    // This is a comment\\n    2 3 +\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5886,7 +5885,7 @@ fn test_TokenString_Comment_Own_Line() {
 }
 
 #[test]
-fn test_TokenString_Comment_At_Start() {
+fn test_tokenstring_comment_at_start() {
     let src = "{ // comment\\n2 3 + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5904,7 +5903,7 @@ fn test_TokenString_Comment_At_Start() {
 }
 
 #[test]
-fn test_TokenString_Multiple_Comment_Lines() {
+fn test_tokenstring_multiple_comment_lines() {
     let src = "{\\n    // First comment\\n    // Second comment\\n    2 3 +\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5922,7 +5921,7 @@ fn test_TokenString_Multiple_Comment_Lines() {
 }
 
 #[test]
-fn test_TokenString_Comments_Nested() {
+fn test_tokenstring_comments_nested() {
     let src = "{ { 2 3 + // inner comment\\n} // outer comment\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5940,7 +5939,7 @@ fn test_TokenString_Comments_Nested() {
 }
 
 #[test]
-fn test_TokenString_Unclosed() {
+fn test_tokenstring_unclosed() {
     let src = "{ 2 3 +";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5955,7 +5954,7 @@ fn test_TokenString_Unclosed() {
 }
 
 #[test]
-fn test_TokenString_Unclosed_Nested() {
+fn test_tokenstring_unclosed_nested() {
     let src = "{ { 2 3 + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5970,7 +5969,7 @@ fn test_TokenString_Unclosed_Nested() {
 }
 
 #[test]
-fn test_TokenString_Extra_Closing_Brace() {
+fn test_tokenstring_extra_closing_brace() {
     let src = "{ 2 3 + } }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -5989,7 +5988,7 @@ fn test_TokenString_Extra_Closing_Brace() {
 }
 
 #[test]
-fn test_TokenString_Only_Closing_Brace() {
+fn test_tokenstring_only_closing_brace() {
     let src = "}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6004,7 +6003,7 @@ fn test_TokenString_Only_Closing_Brace() {
 }
 
 #[test]
-fn test_TokenString_Error_Inside() {
+fn test_tokenstring_error_inside() {
     let src = "{ 2 3a + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6022,7 +6021,7 @@ fn test_TokenString_Error_Inside() {
 }
 
 #[test]
-fn test_TokenString_Function_Body() {
+fn test_tokenstring_function_body() {
     let src = "{ dup * }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6040,7 +6039,7 @@ fn test_TokenString_Function_Body() {
 }
 
 #[test]
-fn test_TokenString_Loop_Body() {
+fn test_tokenstring_loop_body() {
     let src = "{ dup print 1 + }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6058,7 +6057,7 @@ fn test_TokenString_Loop_Body() {
 }
 
 #[test]
-fn test_TokenString_Struct_Fields() {
+fn test_tokenstring_struct_fields() {
     let src = "{ x: y: }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6076,7 +6075,7 @@ fn test_TokenString_Struct_Fields() {
 }
 
 #[test]
-fn test_TokenString_Lambda() {
+fn test_tokenstring_lambda() {
     let src = "{ 2 * }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6094,7 +6093,7 @@ fn test_TokenString_Lambda() {
 }
 
 #[test]
-fn test_TokenString_Array_Map() {
+fn test_tokenstring_array_map() {
     let src = "{ dup * }";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
@@ -6112,7 +6111,7 @@ fn test_TokenString_Array_Map() {
 }
 
 #[test]
-fn test_TokenString_Conditional_Complex() {
+fn test_tokenstring_conditional_complex() {
     let src = "{\\n    dup 0 >\\n        { dup * }\\n        { drop 0 }\\n    if\\n}";
     let mut lexer = sls::lexer::Lexer::new(src);
     let mut got = vec![];
diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml
index 083da64..1dda3a5 100644
--- a/SLS_Tests/cases.yaml
+++ b/SLS_Tests/cases.yaml
@@ -1993,7 +1993,7 @@
   stack_final:
   - type: f32
     value: -0.0
-- name: Char Simple Letter A
+- name: Char Simple Letter Uppercase A
   code: '''A'''
   tokens:
   - type: char
@@ -2005,7 +2005,7 @@
   stack_final:
   - type: char
     value: A
-- name: Char Simple Letter a
+- name: Char Simple Letter Lowercase a
   code: '''a'''
   tokens:
   - type: char
@@ -2017,7 +2017,7 @@
   stack_final:
   - type: char
     value: a
-- name: Char Simple Letter Z
+- name: Char Simple Letter Uppercase Z
   code: '''Z'''
   tokens:
   - type: char
@@ -2029,7 +2029,7 @@
   stack_final:
   - type: char
     value: Z
-- name: Char Simple Letter z
+- name: Char Simple Letter Lowercase z
   code: '''z'''
   tokens:
   - type: char
@@ -2317,42 +2317,6 @@
   stack_final:
   - type: char
     value: '}'
-- name: Char Escape Tab
-  code: '''\\t'''
-  tokens:
-  - type: char
-    value: "\t"
-  operations:
-  - function: push
-    type: char
-    value: "\t"
-  stack_final:
-  - type: char
-    value: "\t"
-- name: Char Escape Backslash
-  code: '''\\\\'''
-  tokens:
-  - type: char
-    value: \
-  operations:
-  - function: push
-    type: char
-    value: \
-  stack_final:
-  - type: char
-    value: \
-- name: Char Escape Null character
-  code: '''\\0'''
-  tokens:
-  - type: char
-    value: "\0"
-  operations:
-  - function: push
-    type: char
-    value: "\0"
-  stack_final:
-  - type: char
-    value: "\0"
 - name: Char Escape Single quote
   code: '''\\'''''
   tokens:
@@ -2365,18 +2329,6 @@
   stack_final:
   - type: char
     value: ''''
-- name: Char Escape Carriage return
-  code: '''\\r'''
-  tokens:
-  - type: char
-    value: "\r"
-  operations:
-  - function: push
-    type: char
-    value: "\r"
-  stack_final:
-  - type: char
-    value: "\r"
 - name: Char Escape Newline
   code: '''\\n'''
   tokens:
@@ -2395,6 +2347,54 @@
     value: '
 
       '
+- name: Char Escape Null character
+  code: '''\\0'''
+  tokens:
+  - type: char
+    value: "\0"
+  operations:
+  - function: push
+    type: char
+    value: "\0"
+  stack_final:
+  - type: char
+    value: "\0"
+- name: Char Escape Backslash
+  code: '''\\\\'''
+  tokens:
+  - type: char
+    value: \
+  operations:
+  - function: push
+    type: char
+    value: \
+  stack_final:
+  - type: char
+    value: \
+- name: Char Escape Tab
+  code: '''\\t'''
+  tokens:
+  - type: char
+    value: "\t"
+  operations:
+  - function: push
+    type: char
+    value: "\t"
+  stack_final:
+  - type: char
+    value: "\t"
+- name: Char Escape Carriage return
+  code: '''\\r'''
+  tokens:
+  - type: char
+    value: "\r"
+  operations:
+  - function: push
+    type: char
+    value: "\r"
+  stack_final:
+  - type: char
+    value: "\r"
 - name: Char With Leading Whitespace
   code: '  ''A'''
   tokens:
diff --git a/SLS_Tests/generate_tests/char_tests.py b/SLS_Tests/generate_tests/char_tests.py
index f461606..3278e9a 100644
--- a/SLS_Tests/generate_tests/char_tests.py
+++ b/SLS_Tests/generate_tests/char_tests.py
@@ -28,10 +28,10 @@ class CharTestGenerator(BaseTestGenerator):
     def generate_basic_tests(self):
         """Generate basic character literal tests."""
         # Simple ASCII letters
-        self.make_success_test("Char Simple Letter A", "'A'", "char", 'A')
-        self.make_success_test("Char Simple Letter a", "'a'", "char", 'a')
-        self.make_success_test("Char Simple Letter Z", "'Z'", "char", 'Z')
-        self.make_success_test("Char Simple Letter z", "'z'", "char", 'z')
+        self.make_success_test("Char Simple Letter Uppercase A", "'A'", "char", 'A')
+        self.make_success_test("Char Simple Letter Lowercase a", "'a'", "char", 'a')
+        self.make_success_test("Char Simple Letter Uppercase Z", "'Z'", "char", 'Z')
+        self.make_success_test("Char Simple Letter Lowercase z", "'z'", "char", 'z')
         
         # Digits
         self.make_success_test("Char Digit 0", "'0'", "char", '0')
diff --git a/SLS_Tests/yaml_to_rust_tests.py b/SLS_Tests/yaml_to_rust_tests.py
index 258e38d..a0620c9 100644
--- a/SLS_Tests/yaml_to_rust_tests.py
+++ b/SLS_Tests/yaml_to_rust_tests.py
@@ -17,6 +17,7 @@ def sanitize_name(name: str) -> str:
     name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
     name = re.sub(r"_+", "_", name)
     name = name.strip("_")
+    name = name.lower()
     if not name:
         name = "unnamed"
     return f"test_{name}"