KylerOlsen/YREA-SLS
KylerOlsen
/
YREA-SLS
1
0
Fork 0
Code Releases 3 Wiki Activity

Added tests generator

This commit is contained in:
Kyler Olsen 2025-11-06 18:59:18 -07:00
parent 3b1e05241e
commit 9f616d3e87
3 changed files with 2595 additions and 1386 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1336
SLS_C/tests/lexer_tests.c
View File

File diff suppressed because it is too large Load Diff

2290
SLS_Tests/cases.yaml
View File

File diff suppressed because it is too large Load Diff

355
SLS_Tests/generate_tests.py Normal file
View File

@ -0,0 +1,355 @@
"""
Test case generator for integer literals in the Stack Language.
Generates comprehensive test cases for all integer types and bases.
"""
from typing import List, Dict, Any, Optional
from dataclasses import dataclass, asdict
@dataclass
class Token:
type: str
value: Any
@dataclass
class Operation:
function: str
type: str
value: Any
@dataclass
class StackItem:
type: str
value: Any
@dataclass
class RuntimeError:
message: str
@dataclass
class TestCase:
name: str
code: str
tokens: List[Dict[str, Any]]
operations: Optional[List[Dict[str, Any]]] = None
stack_final: Optional[List[Dict[str, Any]]] = None
runtime_error: Optional[Dict[str, str]] = None
def to_dict(obj):
"""Convert dataclass to dict, removing None values."""
if obj is None:
return None
d = asdict(obj) if hasattr(obj, '__dataclass_fields__') else obj
return {k: v for k, v in d.items() if v is not None}
class IntegerTestGenerator:
"""Generate test cases for integer literals."""
# Type ranges
TYPE_RANGES = {
'i8': (-128, 127),
'i16': (-32768, 32767),
'i32': (-2147483648, 2147483647),
'i64': (-9223372036854775808, 9223372036854775807),
'u8': (0, 255),
'u16': (0, 65535),
'u32': (0, 4294967295),
'u64': (0, 18446744073709551615),
}
def __init__(self):
self.tests = []
def add_test(self, name: str, code: str, tokens: List[Token],
operations: Optional[List[Operation]] = None,
stack_final: Optional[List[StackItem]] = None,
runtime_error: Optional[RuntimeError] = None):
"""Add a test case."""
test = TestCase(
name=name,
code=code,
tokens=[to_dict(t) for t in tokens],
operations=[to_dict(o) for o in operations] if operations else None,
stack_final=[to_dict(s) for s in stack_final] if stack_final else None,
runtime_error=to_dict(runtime_error) if runtime_error else None
)
self.tests.append(to_dict(test))
def make_push_op(self, type_name: str, value: Any) -> Operation:
"""Create a push operation."""
return Operation(function="push", type=type_name, value=value)
def make_stack_item(self, type_name: str, value: Any) -> StackItem:
"""Create a stack item."""
return StackItem(type=type_name, value=value)
def make_error_token(self, message: str) -> Token:
"""Create an error token."""
return Token(type="error", value=message)
def make_success_test(self, name: str, code: str, type_name: str, value: Any):
"""Create a successful test case."""
token = Token(type=type_name, value=value)
op = self.make_push_op(type_name, value)
stack = self.make_stack_item(type_name, value)
self.add_test(name, code, [token], [op], [stack])
def make_error_test(self, name: str, code: str, error_msg: str):
"""Create an error test case."""
token = self.make_error_token(error_msg)
self.add_test(name, code, [token])
def generate_basic_tests(self):
"""Generate basic test cases."""
# Empty statement
self.add_test("Empty_Statement", "", [], [], [])
# Simple default integers
self.make_success_test("Integer Default Decimal 0", "0", "i64", 0)
self.make_success_test("Integer Default Decimal -1", "-1", "i64", -1)
self.make_success_test("Integer Default Decimal 42", "42", "i64", 42)
self.make_success_test("Integer Default Decimal Leading Zeros", "00042", "i64", 42)
def generate_default_base_tests(self):
"""Generate tests for default type with different bases."""
# Hexadecimal
self.make_success_test("Integer Default Hex 0xFF", "0xFF", "i64", 255)
self.make_success_test("Integer Default Hex 0xdeadbeef", "0xdeadbeef", "i64", 3735928559)
self.make_success_test("Integer Default Hex Max", "0x7FFFFFFFFFFFFFFF", "i64", 9223372036854775807)
# Binary
self.make_success_test("Integer Default Binary 0b1010", "0b1010", "i64", 10)
self.make_success_test("Integer Default Binary All Ones", "0b1111111111111111", "i64", 65535)
# Octal
self.make_success_test("Integer Default Octal 0o755", "0o755", "i64", 493)
self.make_success_test("Integer Default Octal Max Three Digits", "0o777", "i64", 511)
def generate_default_edge_cases(self):
"""Generate edge case tests for default type."""
# Min/max values
self.make_success_test("Integer Default Decimal Max i64",
"9223372036854775807", "i64", 9223372036854775807)
self.make_success_test("Integer Default Decimal Min i64",
"-9223372036854775808", "i64", -9223372036854775808)
# Underscores
self.make_success_test("Integer Default Decimal with Underscore",
"1_000_000", "i64", 1000000)
self.make_success_test("Integer Default Underscore End", "42_", "i64", 42)
self.make_success_test("Integer Default Underscore Double", "4__2", "i64", 42)
# Whitespace
self.make_success_test("Integer Default Whitespace", " 42 ", "i64", 42)
# Zeros in different bases
self.make_success_test("Integer Default Hex Zero", "0x0", "i64", 0)
self.make_success_test("Integer Default Binary Zero", "0b0", "i64", 0)
self.make_success_test("Integer Default Octal Zero", "0o0", "i64", 0)
def generate_default_error_tests(self):
"""Generate error tests for default type."""
self.make_error_test("Integer Default Decimal with Commas Invalid",
"1,000,000",
"Invalid decimal literal: unexpected ',' in decimal integer.")
self.make_error_test("Integer Default Invalid Characters",
"12a3",
"Invalid decimal literal: unexpected 'a' in decimal integer.")
self.make_error_test("Integer Default Invalid Prefix",
"0b2",
"Invalid binary literal: unexpected '2' in binary integer.")
def generate_typed_tests(self, type_name: str):
"""Generate tests for a specific type across all bases."""
min_val, max_val = self.TYPE_RANGES[type_name]
is_unsigned = type_name.startswith('u')
# Basic decimal
test_val = 42 if max_val >= 42 else max_val
self.make_success_test(f"Integer {type_name} Decimal Positive",
f"{test_val}:{type_name}", type_name, test_val)
# Zero
self.make_success_test(f"Integer {type_name} Zero",
f"0:{type_name}", type_name, 0)
# Negative (only for signed types)
if not is_unsigned:
neg_val = -100 if min_val <= -100 else min_val
self.make_success_test(f"Integer {type_name} Decimal Negative",
f"{neg_val}:{type_name}", type_name, neg_val)
# Hexadecimal
hex_val = min(255, max_val)
self.make_success_test(f"Integer {type_name} Hex",
f"0x{hex_val:X}:{type_name}", type_name, hex_val)
# Binary
bin_val = min(15, max_val)
self.make_success_test(f"Integer {type_name} Binary",
f"0b{bin_val:b}:{type_name}", type_name, bin_val)
# Octal
oct_val = min(63, max_val)
self.make_success_test(f"Integer {type_name} Octal",
f"0o{oct_val:o}:{type_name}", type_name, oct_val)
# Max value
self.make_success_test(f"Integer {type_name} Max Value",
f"{max_val}:{type_name}", type_name, max_val)
# Min value
self.make_success_test(f"Integer {type_name} Min Value",
f"{min_val}:{type_name}", type_name, min_val)
# Overflow
overflow_val = max_val + 1
self.make_error_test(f"Integer {type_name} Overflow",
f"{overflow_val}:{type_name}",
f"Integer overflow: {overflow_val} exceeds range for {type_name}.")
# Underflow
underflow_val = min_val - 1
self.make_error_test(f"Integer {type_name} Underflow",
f"{underflow_val}:{type_name}",
f"Integer underflow: {underflow_val} exceeds range for {type_name}.")
def generate_special_typed_tests(self, type_name: str):
"""Generate special tests for specific types."""
min_val, max_val = self.TYPE_RANGES[type_name]
is_unsigned = type_name.startswith('u')
# Underscores with type annotation
if max_val >= 1000000:
self.make_success_test(f"Integer {type_name} With Underscores",
f"1_000_000:{type_name}", type_name, 1000000)
# Special values for specific types
if type_name == 'i8':
self.make_success_test("Integer i8 Hex Max", "0x7F:i8", "i8", 127)
self.make_success_test("Integer i8 Binary Max", "0b01111111:i8", "i8", 127)
self.make_success_test("Integer i8 Octal Max", "0o177:i8", "i8", 127)
self.make_success_test("Integer i8 Negative Hex", "-0x80:i8", "i8", -128)
elif type_name == 'u8':
self.make_success_test("Integer u8 Hex Max", "0xFF:u8", "u8", 255)
self.make_success_test("Integer u8 Binary Max", "0b11111111:u8", "u8", 255)
self.make_success_test("Integer u8 Octal Max", "0o377:u8", "u8", 255)
elif type_name == 'i16':
self.make_success_test("Integer i16 Hex Sample", "0x1234:i16", "i16", 4660)
self.make_success_test("Integer i16 Binary Sample",
"0b1111111100000000:i16", "i16", 65280)
self.make_success_test("Integer i16 Octal Sample", "0o1234:i16", "i16", 668)
elif type_name == 'u16':
self.make_success_test("Integer u16 Hex Max", "0xFFFF:u16", "u16", 65535)
self.make_success_test("Integer u16 Binary Max",
"0b1111111111111111:u16", "u16", 65535)
self.make_success_test("Integer u16 Octal Max", "0o177777:u16", "u16", 65535)
self.make_success_test("Integer u16 Decimal Mid", "50000:u16", "u16", 50000)
elif type_name == 'i32':
self.make_success_test("Integer i32 Hex Sample", "0xABCD:i32", "i32", 43981)
self.make_success_test("Integer i32 Binary Sample",
"0b11110000:i32", "i32", 240)
elif type_name == 'u32':
self.make_success_test("Integer u32 Hex Max", "0xFFFFFFFF:u32", "u32", 4294967295)
self.make_success_test("Integer u32 Binary Sample",
"0b11111111000000001111111100000000:u32",
"u32", 4278255360)
self.make_success_test("Integer u32 Octal Max",
"0o37777777777:u32", "u32", 4294967295)
self.make_success_test("Integer u32 Decimal Mid", "1000000:u32", "u32", 1000000)
elif type_name == 'i64':
self.make_success_test("Integer i64 Decimal Positive 42", "42:i64", "i64", 42)
self.make_success_test("Integer i64 Hex 0xFF", "0xFF:i64", "i64", 255)
self.make_success_test("Integer i64 Binary 0b1010", "0b1010:i64", "i64", 10)
self.make_success_test("Integer i64 Octal 0o755", "0o755:i64", "i64", 493)
elif type_name == 'u64':
self.make_success_test("Integer u64 Hex Max",
"0xFFFFFFFFFFFFFFFF:u64",
"u64", 18446744073709551615)
self.make_success_test("Integer u64 Binary Sample",
"0b1010101010101010:u64", "u64", 43690)
self.make_success_test("Integer u64 Octal Sample", "0o7777:u64", "u64", 4095)
self.make_success_test("Integer u64 Decimal", "42:u64", "u64", 42)
def generate_underscore_tests(self):
"""Generate tests for underscores in different bases."""
self.make_success_test("Integer Hex With Underscores",
"0xDEAD_BEEF:i64", "i64", 3735928559)
self.make_success_test("Integer Binary With Underscores",
"0b1111_0000_1010_0101:i32", "i32", 61605)
self.make_success_test("Integer Octal With Underscores",
"0o7_7_7:i16", "i16", 511)
def generate_all_tests(self) -> List[Dict[str, Any]]:
"""Generate all test cases."""
# Basic tests
self.generate_basic_tests()
# Default type (i64) comprehensive tests
self.generate_default_base_tests()
self.generate_default_edge_cases()
self.generate_default_error_tests()
# Tests for each specific type
for type_name in ['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64']:
self.generate_typed_tests(type_name)
self.generate_special_typed_tests(type_name)
# Additional edge cases
self.generate_underscore_tests()
return self.tests
def generate_integer_literal_tests() -> List[Dict[str, Any]]:
"""
Main function to generate all integer literal test cases.
Returns:
List of test case dictionaries ready for serialization
"""
generator = IntegerTestGenerator()
return generator.generate_all_tests()
if __name__ == "__main__":
# import json
import yaml
# Generate tests
tests = generate_integer_literal_tests()
# Print summary
print(f"Generated {len(tests)} test cases")
# # Save as JSON
# with open("integer_literal_tests.json", "w") as f:
# json.dump(tests, f, indent=2)
# print("Saved to integer_literal_tests.json")
# # Save as YAML
# with open("integer_literal_tests.yaml", "w") as f:
# yaml.dump(tests, f, default_flow_style=False, sort_keys=False)
# print("Saved to integer_literal_tests.yaml")
# Save as YAML
with open("cases.yaml", "w") as f:
yaml.dump(tests, f, default_flow_style=False, sort_keys=False)
# Print first few tests as example
print("\nFirst 3 test cases:")
print(yaml.dump(tests[:3], default_flow_style=False, sort_keys=False))