Fixed and added more test cases
This commit is contained in:
parent
681322ea2e
commit
3b1e05241e
|
|
@ -16,7 +16,7 @@
|
|||
#include "tests/tests.h"
|
||||
|
||||
|
||||
static const size_t NUM_OF_TESTS = 20;
|
||||
static const size_t NUM_OF_TESTS = 89;
|
||||
|
||||
static TestResult test_Empty_Statement() {
|
||||
LexerTest test = start_up_test("test_Empty_Statement", "");
|
||||
|
|
@ -151,7 +151,7 @@ static TestResult test_Integer_i8_Overflow() {
|
|||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ static TestResult test_Integer_i8_Underflow() {
|
|||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
|
|
@ -212,6 +212,684 @@ static TestResult test_Integer_Default_Underscore_Double() {
|
|||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Decimal_Max_i64() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Decimal_Max_i64", "9223372036854775807");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 9223372036854775807})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Decimal_Min_i64() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Decimal_Min_i64", "-9223372036854775808");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -9223372036854775808})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Hex_Max() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Hex_Max", "0x7FFFFFFFFFFFFFFF");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 9223372036854775807})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Binary_All_Ones() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Binary_All_Ones", "0b1111111111111111");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 65535})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Octal_Max_Three_Digits() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Octal_Max_Three_Digits", "0o777");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 511})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Decimal_Positive() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Decimal_Positive", "42:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 42})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Hex", "0xFF:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 255})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Binary", "0b1010:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 10})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Octal", "0o755:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 493})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_With_Underscores() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_With_Underscores", "1_000_000:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 1000000})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Max_Value", "9223372036854775807:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 9223372036854775807})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i64_Min_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i64_Min_Value", "-9223372036854775808:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, -9223372036854775808})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Decimal_Positive() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Decimal_Positive", "42:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 42})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Decimal_Negative() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Decimal_Negative", "-100:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, -100})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Hex", "0xABCD:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 43981})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Binary", "0b11110000:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 240})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Octal", "0o777:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 511})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Max_Value", "2147483647:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 2147483647})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Min_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Min_Value", "-2147483648:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, -2147483648})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Overflow", "2147483648:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 2147483648 exceeds range for i32."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i32_Underflow() {
|
||||
LexerTest test = start_up_test("test_Integer_i32_Underflow", "-2147483649:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){54, "Integer underflow: -2147483649 exceeds range for i32."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Decimal_Positive() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Decimal_Positive", "1000:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 1000})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Decimal_Negative() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Decimal_Negative", "-1000:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, -1000})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Hex", "0x1234:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 4660})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Binary", "0b1111111100000000:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 65280})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Octal", "0o1234:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 668})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Max_Value", "32767:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 32767})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Min_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Min_Value", "-32768:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, -32768})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Overflow", "32768:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: 32768 exceeds range for i16."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i16_Underflow() {
|
||||
LexerTest test = start_up_test("test_Integer_i16_Underflow", "-32769:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){49, "Integer underflow: -32769 exceeds range for i16."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i8_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_i8_Hex", "0x7F:i8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i8_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_i8_Binary", "0b01111111:i8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i8_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_i8_Octal", "0o177:i8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 127})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i8_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_i8_Zero", "0:i8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_i8_Negative_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_i8_Negative_Hex", "-0x80:i8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I8, -128})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Decimal() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Decimal", "42:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 42})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Hex", "0xFFFFFFFFFFFFFFFF:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 18446744073709551615})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Binary", "0b1010101010101010:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 43690})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Octal", "0o7777:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 4095})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Max_Value", "18446744073709551615:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 18446744073709551615})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Zero", "0:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U64, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Overflow", "18446744073709551616:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){62, "Integer overflow: 18446744073709551616 exceeds range for u64."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u64_Negative_Invalid() {
|
||||
LexerTest test = start_up_test("test_Integer_u64_Negative_Invalid", "-1:u64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u64."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Decimal() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Decimal", "1000000:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 1000000})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Hex", "0xFFFFFFFF:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Binary", "0b11111111000000001111111100000000:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4278255360})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Octal", "0o37777777777:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Max_Value", "4294967295:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U32, 4294967295})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Overflow", "4294967296:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){52, "Integer overflow: 4294967296 exceeds range for u32."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u32_Negative_Invalid() {
|
||||
LexerTest test = start_up_test("test_Integer_u32_Negative_Invalid", "-1:u32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u32."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Decimal() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Decimal", "50000:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 50000})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Hex", "0xFFFF:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Binary", "0b1111111111111111:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Octal", "0o177777:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Max_Value() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Max_Value", "65535:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U16, 65535})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Overflow", "65536:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: 65536 exceeds range for u16."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u16_Negative_Invalid() {
|
||||
LexerTest test = start_up_test("test_Integer_u16_Negative_Invalid", "-1:u16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u16."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Hex() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Hex", "0xFF:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Binary() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Binary", "0b11111111:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Octal() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Octal", "0o377:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 255})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Zero", "0:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_U8, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Overflow() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Overflow", "256:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 256 exceeds range for u8."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_u8_Negative_Invalid() {
|
||||
LexerTest test = start_up_test("test_Integer_u8_Negative_Invalid", "-1:u8");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer underflow: -1 exceeds range for u8."})) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Hex_With_Underscores() {
|
||||
LexerTest test = start_up_test("test_Integer_Hex_With_Underscores", "0xDEAD_BEEF:i64");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 3735928559})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Binary_With_Underscores() {
|
||||
LexerTest test = start_up_test("test_Integer_Binary_With_Underscores", "0b1111_0000_1010_0101:i32");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I32, 61605})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Octal_With_Underscores() {
|
||||
LexerTest test = start_up_test("test_Integer_Octal_With_Underscores", "0o7_7_7:i16");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I16, 511})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Hex_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Hex_Zero", "0x0");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Binary_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Binary_Zero", "0b0");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
static TestResult test_Integer_Default_Octal_Zero() {
|
||||
LexerTest test = start_up_test("test_Integer_Default_Octal_Zero", "0o0");
|
||||
LexerResult result = lexical_analysis(&test.lexer_info);
|
||||
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
|
||||
size_t i = 0;
|
||||
if (test_integer_value(&test, result, i++, &(TestIntegerValue){INTEGER_I64, 0})) return test.result;
|
||||
if (test_eof_value(&test, result, i++, 0)) return test.result;
|
||||
return pass_test(&test, result);
|
||||
}
|
||||
|
||||
TestsReport run_lexer_tests() {
|
||||
TestsReport test_report = (TestsReport) {
|
||||
.section = "lexer_tests",
|
||||
|
|
@ -241,6 +919,75 @@ TestsReport run_lexer_tests() {
|
|||
test_report.tests[i++] = test_Integer_Default_Invalid_Prefix();
|
||||
test_report.tests[i++] = test_Integer_Default_Underscore_End();
|
||||
test_report.tests[i++] = test_Integer_Default_Underscore_Double();
|
||||
test_report.tests[i++] = test_Integer_Default_Decimal_Max_i64();
|
||||
test_report.tests[i++] = test_Integer_Default_Decimal_Min_i64();
|
||||
test_report.tests[i++] = test_Integer_Default_Hex_Max();
|
||||
test_report.tests[i++] = test_Integer_Default_Binary_All_Ones();
|
||||
test_report.tests[i++] = test_Integer_Default_Octal_Max_Three_Digits();
|
||||
test_report.tests[i++] = test_Integer_i64_Decimal_Positive();
|
||||
test_report.tests[i++] = test_Integer_i64_Hex();
|
||||
test_report.tests[i++] = test_Integer_i64_Binary();
|
||||
test_report.tests[i++] = test_Integer_i64_Octal();
|
||||
test_report.tests[i++] = test_Integer_i64_With_Underscores();
|
||||
test_report.tests[i++] = test_Integer_i64_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_i64_Min_Value();
|
||||
test_report.tests[i++] = test_Integer_i32_Decimal_Positive();
|
||||
test_report.tests[i++] = test_Integer_i32_Decimal_Negative();
|
||||
test_report.tests[i++] = test_Integer_i32_Hex();
|
||||
test_report.tests[i++] = test_Integer_i32_Binary();
|
||||
test_report.tests[i++] = test_Integer_i32_Octal();
|
||||
test_report.tests[i++] = test_Integer_i32_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_i32_Min_Value();
|
||||
test_report.tests[i++] = test_Integer_i32_Overflow();
|
||||
test_report.tests[i++] = test_Integer_i32_Underflow();
|
||||
test_report.tests[i++] = test_Integer_i16_Decimal_Positive();
|
||||
test_report.tests[i++] = test_Integer_i16_Decimal_Negative();
|
||||
test_report.tests[i++] = test_Integer_i16_Hex();
|
||||
test_report.tests[i++] = test_Integer_i16_Binary();
|
||||
test_report.tests[i++] = test_Integer_i16_Octal();
|
||||
test_report.tests[i++] = test_Integer_i16_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_i16_Min_Value();
|
||||
test_report.tests[i++] = test_Integer_i16_Overflow();
|
||||
test_report.tests[i++] = test_Integer_i16_Underflow();
|
||||
test_report.tests[i++] = test_Integer_i8_Hex();
|
||||
test_report.tests[i++] = test_Integer_i8_Binary();
|
||||
test_report.tests[i++] = test_Integer_i8_Octal();
|
||||
test_report.tests[i++] = test_Integer_i8_Zero();
|
||||
test_report.tests[i++] = test_Integer_i8_Negative_Hex();
|
||||
test_report.tests[i++] = test_Integer_u64_Decimal();
|
||||
test_report.tests[i++] = test_Integer_u64_Hex();
|
||||
test_report.tests[i++] = test_Integer_u64_Binary();
|
||||
test_report.tests[i++] = test_Integer_u64_Octal();
|
||||
test_report.tests[i++] = test_Integer_u64_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_u64_Zero();
|
||||
test_report.tests[i++] = test_Integer_u64_Overflow();
|
||||
test_report.tests[i++] = test_Integer_u64_Negative_Invalid();
|
||||
test_report.tests[i++] = test_Integer_u32_Decimal();
|
||||
test_report.tests[i++] = test_Integer_u32_Hex();
|
||||
test_report.tests[i++] = test_Integer_u32_Binary();
|
||||
test_report.tests[i++] = test_Integer_u32_Octal();
|
||||
test_report.tests[i++] = test_Integer_u32_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_u32_Overflow();
|
||||
test_report.tests[i++] = test_Integer_u32_Negative_Invalid();
|
||||
test_report.tests[i++] = test_Integer_u16_Decimal();
|
||||
test_report.tests[i++] = test_Integer_u16_Hex();
|
||||
test_report.tests[i++] = test_Integer_u16_Binary();
|
||||
test_report.tests[i++] = test_Integer_u16_Octal();
|
||||
test_report.tests[i++] = test_Integer_u16_Max_Value();
|
||||
test_report.tests[i++] = test_Integer_u16_Overflow();
|
||||
test_report.tests[i++] = test_Integer_u16_Negative_Invalid();
|
||||
test_report.tests[i++] = test_Integer_u8_Hex();
|
||||
test_report.tests[i++] = test_Integer_u8_Binary();
|
||||
test_report.tests[i++] = test_Integer_u8_Octal();
|
||||
test_report.tests[i++] = test_Integer_u8_Zero();
|
||||
test_report.tests[i++] = test_Integer_u8_Overflow();
|
||||
test_report.tests[i++] = test_Integer_u8_Negative_Invalid();
|
||||
test_report.tests[i++] = test_Integer_Hex_With_Underscores();
|
||||
test_report.tests[i++] = test_Integer_Binary_With_Underscores();
|
||||
test_report.tests[i++] = test_Integer_Octal_With_Underscores();
|
||||
test_report.tests[i++] = test_Integer_Default_Hex_Zero();
|
||||
test_report.tests[i++] = test_Integer_Default_Binary_Zero();
|
||||
test_report.tests[i++] = test_Integer_Default_Octal_Zero();
|
||||
|
||||
return test_report;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -179,13 +179,15 @@
|
|||
|
||||
- name: Integer i8 Overflow
|
||||
code: "128:i8"
|
||||
runtime_error:
|
||||
message: "Integer overflow: 128 exceeds range for i8."
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 128 exceeds range for i8."
|
||||
|
||||
- name: Integer i8 Underflow
|
||||
code: "-129:i8"
|
||||
runtime_error:
|
||||
message: "Integer underflow: -129 exceeds range for i8."
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -129 exceeds range for i8."
|
||||
|
||||
- name: Integer Default Invalid Characters
|
||||
code: "12a3"
|
||||
|
|
@ -238,6 +240,830 @@
|
|||
- type: i64
|
||||
value: 42
|
||||
|
||||
# Additional i64 (default) coverage
|
||||
- name: Integer Default Decimal Max i64
|
||||
code: "9223372036854775807"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 9223372036854775807
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
|
||||
- name: Integer Default Decimal Min i64
|
||||
code: "-9223372036854775808"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: -9223372036854775808
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: -9223372036854775808
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: -9223372036854775808
|
||||
|
||||
- name: Integer Default Hex Max
|
||||
code: "0x7FFFFFFFFFFFFFFF"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 9223372036854775807
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
|
||||
- name: Integer Default Binary All Ones
|
||||
code: "0b1111111111111111"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 65535
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 65535
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 65535
|
||||
|
||||
- name: Integer Default Octal Max Three Digits
|
||||
code: "0o777"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 511
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 511
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 511
|
||||
|
||||
# Explicit i64 coverage
|
||||
- name: Integer i64 Decimal Positive
|
||||
code: "42:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 42
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 42
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 42
|
||||
|
||||
- name: Integer i64 Hex
|
||||
code: "0xFF:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 255
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 255
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 255
|
||||
|
||||
- name: Integer i64 Binary
|
||||
code: "0b1010:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 10
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 10
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 10
|
||||
|
||||
- name: Integer i64 Octal
|
||||
code: "0o755:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 493
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 493
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 493
|
||||
|
||||
- name: Integer i64 With Underscores
|
||||
code: "1_000_000:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 1000000
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 1000000
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 1000000
|
||||
|
||||
- name: Integer i64 Max Value
|
||||
code: "9223372036854775807:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 9223372036854775807
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 9223372036854775807
|
||||
|
||||
- name: Integer i64 Min Value
|
||||
code: "-9223372036854775808:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: -9223372036854775808
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: -9223372036854775808
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: -9223372036854775808
|
||||
|
||||
# i32 coverage
|
||||
- name: Integer i32 Decimal Positive
|
||||
code: "42:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 42
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 42
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 42
|
||||
|
||||
- name: Integer i32 Decimal Negative
|
||||
code: "-100:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: -100
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: -100
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: -100
|
||||
|
||||
- name: Integer i32 Hex
|
||||
code: "0xABCD:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 43981
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 43981
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 43981
|
||||
|
||||
- name: Integer i32 Binary
|
||||
code: "0b11110000:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 240
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 240
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 240
|
||||
|
||||
- name: Integer i32 Octal
|
||||
code: "0o777:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 511
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 511
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 511
|
||||
|
||||
- name: Integer i32 Max Value
|
||||
code: "2147483647:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 2147483647
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 2147483647
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 2147483647
|
||||
|
||||
- name: Integer i32 Min Value
|
||||
code: "-2147483648:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: -2147483648
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: -2147483648
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: -2147483648
|
||||
|
||||
- name: Integer i32 Overflow
|
||||
code: "2147483648:i32"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 2147483648 exceeds range for i32."
|
||||
|
||||
- name: Integer i32 Underflow
|
||||
code: "-2147483649:i32"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -2147483649 exceeds range for i32."
|
||||
|
||||
# i16 coverage
|
||||
- name: Integer i16 Decimal Positive
|
||||
code: "1000:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 1000
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 1000
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 1000
|
||||
|
||||
- name: Integer i16 Decimal Negative
|
||||
code: "-1000:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: -1000
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: -1000
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: -1000
|
||||
|
||||
- name: Integer i16 Hex
|
||||
code: "0x1234:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 4660
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 4660
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 4660
|
||||
|
||||
- name: Integer i16 Binary
|
||||
code: "0b1111111100000000:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 65280
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 65280
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 65280
|
||||
|
||||
- name: Integer i16 Octal
|
||||
code: "0o1234:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 668
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 668
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 668
|
||||
|
||||
- name: Integer i16 Max Value
|
||||
code: "32767:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 32767
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 32767
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 32767
|
||||
|
||||
- name: Integer i16 Min Value
|
||||
code: "-32768:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: -32768
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: -32768
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: -32768
|
||||
|
||||
- name: Integer i16 Overflow
|
||||
code: "32768:i16"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 32768 exceeds range for i16."
|
||||
|
||||
- name: Integer i16 Underflow
|
||||
code: "-32769:i16"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -32769 exceeds range for i16."
|
||||
|
||||
# i8 coverage (additional to existing)
|
||||
- name: Integer i8 Hex
|
||||
code: "0x7F:i8"
|
||||
tokens:
|
||||
- type: i8
|
||||
value: 127
|
||||
operations:
|
||||
- function: push
|
||||
type: i8
|
||||
value: 127
|
||||
stack_final:
|
||||
- type: i8
|
||||
value: 127
|
||||
|
||||
- name: Integer i8 Binary
|
||||
code: "0b01111111:i8"
|
||||
tokens:
|
||||
- type: i8
|
||||
value: 127
|
||||
operations:
|
||||
- function: push
|
||||
type: i8
|
||||
value: 127
|
||||
stack_final:
|
||||
- type: i8
|
||||
value: 127
|
||||
|
||||
- name: Integer i8 Octal
|
||||
code: "0o177:i8"
|
||||
tokens:
|
||||
- type: i8
|
||||
value: 127
|
||||
operations:
|
||||
- function: push
|
||||
type: i8
|
||||
value: 127
|
||||
stack_final:
|
||||
- type: i8
|
||||
value: 127
|
||||
|
||||
- name: Integer i8 Zero
|
||||
code: "0:i8"
|
||||
tokens:
|
||||
- type: i8
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: i8
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: i8
|
||||
value: 0
|
||||
|
||||
- name: Integer i8 Negative Hex
|
||||
code: "-0x80:i8"
|
||||
tokens:
|
||||
- type: i8
|
||||
value: -128
|
||||
operations:
|
||||
- function: push
|
||||
type: i8
|
||||
value: -128
|
||||
stack_final:
|
||||
- type: i8
|
||||
value: -128
|
||||
|
||||
# u64 coverage
|
||||
- name: Integer u64 Decimal
|
||||
code: "42:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 42
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 42
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 42
|
||||
|
||||
- name: Integer u64 Hex
|
||||
code: "0xFFFFFFFFFFFFFFFF:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 18446744073709551615
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 18446744073709551615
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 18446744073709551615
|
||||
|
||||
- name: Integer u64 Binary
|
||||
code: "0b1010101010101010:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 43690
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 43690
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 43690
|
||||
|
||||
- name: Integer u64 Octal
|
||||
code: "0o7777:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 4095
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 4095
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 4095
|
||||
|
||||
- name: Integer u64 Max Value
|
||||
code: "18446744073709551615:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 18446744073709551615
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 18446744073709551615
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 18446744073709551615
|
||||
|
||||
- name: Integer u64 Zero
|
||||
code: "0:u64"
|
||||
tokens:
|
||||
- type: u64
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: u64
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: u64
|
||||
value: 0
|
||||
|
||||
- name: Integer u64 Overflow
|
||||
code: "18446744073709551616:u64"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 18446744073709551616 exceeds range for u64."
|
||||
|
||||
- name: Integer u64 Negative Invalid
|
||||
code: "-1:u64"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -1 exceeds range for u64."
|
||||
|
||||
# u32 coverage
|
||||
- name: Integer u32 Decimal
|
||||
code: "1000000:u32"
|
||||
tokens:
|
||||
- type: u32
|
||||
value: 1000000
|
||||
operations:
|
||||
- function: push
|
||||
type: u32
|
||||
value: 1000000
|
||||
stack_final:
|
||||
- type: u32
|
||||
value: 1000000
|
||||
|
||||
- name: Integer u32 Hex
|
||||
code: "0xFFFFFFFF:u32"
|
||||
tokens:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
operations:
|
||||
- function: push
|
||||
type: u32
|
||||
value: 4294967295
|
||||
stack_final:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
|
||||
- name: Integer u32 Binary
|
||||
code: "0b11111111000000001111111100000000:u32"
|
||||
tokens:
|
||||
- type: u32
|
||||
value: 4278255360
|
||||
operations:
|
||||
- function: push
|
||||
type: u32
|
||||
value: 4278255360
|
||||
stack_final:
|
||||
- type: u32
|
||||
value: 4278255360
|
||||
|
||||
- name: Integer u32 Octal
|
||||
code: "0o37777777777:u32"
|
||||
tokens:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
operations:
|
||||
- function: push
|
||||
type: u32
|
||||
value: 4294967295
|
||||
stack_final:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
|
||||
- name: Integer u32 Max Value
|
||||
code: "4294967295:u32"
|
||||
tokens:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
operations:
|
||||
- function: push
|
||||
type: u32
|
||||
value: 4294967295
|
||||
stack_final:
|
||||
- type: u32
|
||||
value: 4294967295
|
||||
|
||||
- name: Integer u32 Overflow
|
||||
code: "4294967296:u32"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 4294967296 exceeds range for u32."
|
||||
|
||||
- name: Integer u32 Negative Invalid
|
||||
code: "-1:u32"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -1 exceeds range for u32."
|
||||
|
||||
# u16 coverage
|
||||
- name: Integer u16 Decimal
|
||||
code: "50000:u16"
|
||||
tokens:
|
||||
- type: u16
|
||||
value: 50000
|
||||
operations:
|
||||
- function: push
|
||||
type: u16
|
||||
value: 50000
|
||||
stack_final:
|
||||
- type: u16
|
||||
value: 50000
|
||||
|
||||
- name: Integer u16 Hex
|
||||
code: "0xFFFF:u16"
|
||||
tokens:
|
||||
- type: u16
|
||||
value: 65535
|
||||
operations:
|
||||
- function: push
|
||||
type: u16
|
||||
value: 65535
|
||||
stack_final:
|
||||
- type: u16
|
||||
value: 65535
|
||||
|
||||
- name: Integer u16 Binary
|
||||
code: "0b1111111111111111:u16"
|
||||
tokens:
|
||||
- type: u16
|
||||
value: 65535
|
||||
operations:
|
||||
- function: push
|
||||
type: u16
|
||||
value: 65535
|
||||
stack_final:
|
||||
- type: u16
|
||||
value: 65535
|
||||
|
||||
- name: Integer u16 Octal
|
||||
code: "0o177777:u16"
|
||||
tokens:
|
||||
- type: u16
|
||||
value: 65535
|
||||
operations:
|
||||
- function: push
|
||||
type: u16
|
||||
value: 65535
|
||||
stack_final:
|
||||
- type: u16
|
||||
value: 65535
|
||||
|
||||
- name: Integer u16 Max Value
|
||||
code: "65535:u16"
|
||||
tokens:
|
||||
- type: u16
|
||||
value: 65535
|
||||
operations:
|
||||
- function: push
|
||||
type: u16
|
||||
value: 65535
|
||||
stack_final:
|
||||
- type: u16
|
||||
value: 65535
|
||||
|
||||
- name: Integer u16 Overflow
|
||||
code: "65536:u16"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 65536 exceeds range for u16."
|
||||
|
||||
- name: Integer u16 Negative Invalid
|
||||
code: "-1:u16"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -1 exceeds range for u16."
|
||||
|
||||
# u8 coverage (additional to existing)
|
||||
- name: Integer u8 Hex
|
||||
code: "0xFF:u8"
|
||||
tokens:
|
||||
- type: u8
|
||||
value: 255
|
||||
operations:
|
||||
- function: push
|
||||
type: u8
|
||||
value: 255
|
||||
stack_final:
|
||||
- type: u8
|
||||
value: 255
|
||||
|
||||
- name: Integer u8 Binary
|
||||
code: "0b11111111:u8"
|
||||
tokens:
|
||||
- type: u8
|
||||
value: 255
|
||||
operations:
|
||||
- function: push
|
||||
type: u8
|
||||
value: 255
|
||||
stack_final:
|
||||
- type: u8
|
||||
value: 255
|
||||
|
||||
- name: Integer u8 Octal
|
||||
code: "0o377:u8"
|
||||
tokens:
|
||||
- type: u8
|
||||
value: 255
|
||||
operations:
|
||||
- function: push
|
||||
type: u8
|
||||
value: 255
|
||||
stack_final:
|
||||
- type: u8
|
||||
value: 255
|
||||
|
||||
- name: Integer u8 Zero
|
||||
code: "0:u8"
|
||||
tokens:
|
||||
- type: u8
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: u8
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: u8
|
||||
value: 0
|
||||
|
||||
- name: Integer u8 Overflow
|
||||
code: "256:u8"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer overflow: 256 exceeds range for u8."
|
||||
|
||||
- name: Integer u8 Negative Invalid
|
||||
code: "-1:u8"
|
||||
tokens:
|
||||
- type: error
|
||||
value: "Integer underflow: -1 exceeds range for u8."
|
||||
|
||||
# Edge cases with underscores in different bases
|
||||
- name: Integer Hex With Underscores
|
||||
code: "0xDEAD_BEEF:i64"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 3735928559
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 3735928559
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 3735928559
|
||||
|
||||
- name: Integer Binary With Underscores
|
||||
code: "0b1111_0000_1010_0101:i32"
|
||||
tokens:
|
||||
- type: i32
|
||||
value: 61605
|
||||
operations:
|
||||
- function: push
|
||||
type: i32
|
||||
value: 61605
|
||||
stack_final:
|
||||
- type: i32
|
||||
value: 61605
|
||||
|
||||
- name: Integer Octal With Underscores
|
||||
code: "0o7_7_7:i16"
|
||||
tokens:
|
||||
- type: i16
|
||||
value: 511
|
||||
operations:
|
||||
- function: push
|
||||
type: i16
|
||||
value: 511
|
||||
stack_final:
|
||||
- type: i16
|
||||
value: 511
|
||||
|
||||
# Zero in different bases
|
||||
- name: Integer Default Hex Zero
|
||||
code: "0x0"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 0
|
||||
|
||||
- name: Integer Default Binary Zero
|
||||
code: "0b0"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 0
|
||||
|
||||
- name: Integer Default Octal Zero
|
||||
code: "0o0"
|
||||
tokens:
|
||||
- type: i64
|
||||
value: 0
|
||||
operations:
|
||||
- function: push
|
||||
type: i64
|
||||
value: 0
|
||||
stack_final:
|
||||
- type: i64
|
||||
value: 0
|
||||
|
||||
# Basic Floats
|
||||
# Basic Strings
|
||||
# Basic Booleans
|
||||
|
|
|
|||
Loading…
Reference in New Issue