994 lines
50 KiB
C
994 lines
50 KiB
C
// Kyler Olsen
|
|
// YREA SLS
|
|
// Lexer Tests
|
|
// October 2025
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
|
|
#include "sls/sls_errors.h"
|
|
#include "sls/lexer.h"
|
|
#include "sls/string.h"
|
|
#include "tests/lexer_test_helpers.h"
|
|
#include "tests/tests.h"
|
|
|
|
|
|
static const size_t NUM_OF_TESTS = 89;
|
|
|
|
static TestResult test_Empty_Statement() {
|
|
LexerTest test = start_up_test("test_Empty_Statement", "");
|
|
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;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_Default_Decimal_0() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Decimal_0", "0");
|
|
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_Decimal_1() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Decimal_1", "-1");
|
|
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, -1})) 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_Leading_Zeros() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Decimal_Leading_Zeros", "00042");
|
|
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_Default_Hex_0xFF() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Hex_0xFF", "0xFF");
|
|
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_Default_Hex_0xdeadbeef() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Hex_0xdeadbeef", "0xdeadbeef");
|
|
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_Default_Binary_0b1010() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Binary_0b1010", "0b1010");
|
|
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_Default_Octal_0o755() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Octal_0o755", "0o755");
|
|
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_i8_Decimal_127() {
|
|
LexerTest test = start_up_test("test_Integer_i8_Decimal_127", "127: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_Decimal_128() {
|
|
LexerTest test = start_up_test("test_Integer_i8_Decimal_128", "-128: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_u8_Decimal_255() {
|
|
LexerTest test = start_up_test("test_Integer_u8_Decimal_255", "255: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_Default_Decimal_with_Underscore() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Underscore", "1_000_000");
|
|
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_Default_Decimal_with_Commas_Invalid() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Decimal_with_Commas_Invalid", "1,000,000");
|
|
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){60, "Invalid decimal literal: unexpected ',' in decimal integer."})) return test.result;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_i8_Overflow() {
|
|
LexerTest test = start_up_test("test_Integer_i8_Overflow", "128: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_for_error(&test, result, i++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_i8_Underflow() {
|
|
LexerTest test = start_up_test("test_Integer_i8_Underflow", "-129: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_for_error(&test, result, i++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_Default_Invalid_Characters() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Invalid_Characters", "12a3");
|
|
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){60, "Invalid decimal literal: unexpected 'a' in decimal integer."})) return test.result;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_Default_Whitespace() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Whitespace", " 42 ");
|
|
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_Default_Invalid_Prefix() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Invalid_Prefix", "0b2");
|
|
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){58, "Invalid binary literal: unexpected '2' in binary integer."})) return test.result;
|
|
return pass_test(&test, result);
|
|
}
|
|
|
|
static TestResult test_Integer_Default_Underscore_End() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Underscore_End", "42_");
|
|
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_Default_Underscore_Double() {
|
|
LexerTest test = start_up_test("test_Integer_Default_Underscore_Double", "4__2");
|
|
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_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",
|
|
.count = NUM_OF_TESTS,
|
|
.tests = (TestResult *)malloc(sizeof(TestResult) * NUM_OF_TESTS),
|
|
};
|
|
|
|
size_t i = 0;
|
|
|
|
test_report.tests[i++] = test_Empty_Statement();
|
|
test_report.tests[i++] = test_Integer_Default_Decimal_0();
|
|
test_report.tests[i++] = test_Integer_Default_Decimal_1();
|
|
test_report.tests[i++] = test_Integer_Default_Decimal_Leading_Zeros();
|
|
test_report.tests[i++] = test_Integer_Default_Hex_0xFF();
|
|
test_report.tests[i++] = test_Integer_Default_Hex_0xdeadbeef();
|
|
test_report.tests[i++] = test_Integer_Default_Binary_0b1010();
|
|
test_report.tests[i++] = test_Integer_Default_Octal_0o755();
|
|
test_report.tests[i++] = test_Integer_i8_Decimal_127();
|
|
test_report.tests[i++] = test_Integer_i8_Decimal_128();
|
|
test_report.tests[i++] = test_Integer_u8_Decimal_255();
|
|
test_report.tests[i++] = test_Integer_Default_Decimal_with_Underscore();
|
|
test_report.tests[i++] = test_Integer_Default_Decimal_with_Commas_Invalid();
|
|
test_report.tests[i++] = test_Integer_i8_Overflow();
|
|
test_report.tests[i++] = test_Integer_i8_Underflow();
|
|
test_report.tests[i++] = test_Integer_Default_Invalid_Characters();
|
|
test_report.tests[i++] = test_Integer_Default_Whitespace();
|
|
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;
|
|
}
|