Skip to content

TESTING_GUIDE.md

Latest commit

 

History

History
354 lines (286 loc) · 8.22 KB

TESTING_GUIDE.md

File metadata and controls

354 lines (286 loc) · 8.22 KB

ZIP Compiler - Complete Test Suite Summary

Overview

✅ 46 comprehensive test cases have been created to validate the ZIP compiler functionality across all language features.

Quick Stats

  • Total Tests: 46
  • Pass Rate: 100% (46/46 passing)
  • Categories: 5
  • Example Programs: 8 included
  • Coverage: All language features

Test Categories

1. Basic Functionality (10 tests)

Core language features including:

  • ✓ Variable declaration and assignment
  • ✓ All arithmetic operators
  • ✓ Comparison operators
  • ✓ Logical operators
  • ✓ Unary operators
  • ✓ Boolean and string literals

2. Functions (6 tests)

Function definition and usage:

  • ✓ Functions with 0-6 parameters
  • ✓ Simple recursion (factorial)
  • ✓ Mutual recursion (is_even/is_odd)
  • ✓ Return statements

3. Control Flow (12 tests)

Loop and conditional statements:

  • ✓ If/else statements
  • ✓ If/else if/else chains
  • ✓ While loops with break/continue
  • ✓ For loops with break/continue
  • ✓ Nested loops
  • ✓ Break/continue in nested structures

4. Edge Cases (12 tests)

Complex scenarios and edge conditions:

  • ✓ Large numbers (999999+)
  • ✓ Negative numbers
  • ✓ Zero values
  • ✓ Complex expressions with precedence
  • ✓ Deeply nested expressions
  • ✓ Multiple functions in one program
  • ✓ Fibonacci sequence
  • ✓ GCD algorithm
  • ✓ Nested if/else structures
  • ✓ Complex boolean logic

5. Error Detection (6 tests)

Compiler validates and rejects:

  • ✓ Undeclared variables
  • ✓ Undefined functions
  • ✓ Break outside loops
  • ✓ Continue outside loops
  • ✓ Too many function arguments
  • ✓ Invalid syntax

Example Program Files

8 ready-to-use example programs in examples/:

test_arithmetic.zip            - Basic arithmetic operations
test_recursion.zip             - Factorial recursion
test_loops.zip                 - Loop control (break/continue)
test_nested_loops.zip          - Nested loops and structures
test_strings.zip               - String literals and printing
test_booleans.zip              - Boolean operations and comparisons
test_functions.zip             - Multi-parameter function calls
test_mutual_recursion.zip      - Mutual recursion patterns

Running Example Programs

# Compile an example
python src/main.py examples/test_arithmetic.zip -o test_arithmetic

# Generate assembly
python src/main.py examples/test_recursion.zip -o test_recursion.s

# Assemble and link (on Linux/WSL)
gcc -o test_arithmetic test_arithmetic.s -no-pie
./test_arithmetic

Running Tests

Option 1: Full Test Suite

python test_suite.py

Output:

BASIC FUNCTIONALITY TESTS
[PASS] empty_main
[PASS] simple_variable
[PASS] multiple_variables
...

CONTROL FLOW TESTS
[PASS] if_statement
[PASS] if_else_statement
...

TEST SUMMARY
Passed: 46/46
[OK] ALL TESTS PASSED! Compiler is working correctly!

Option 2: Individual Tests

# Compile a specific example
python src/main.py examples/test_functions.zip -o functions_test

# Run through compiler
python src/lexer.py < examples/test_arithmetic.zip
python src/parser.py < examples/test_recursion.zip
python src/codegen.py < examples/test_loops.zip

Option 3: Optimization Benchmarks

python test_optimizations.py

Validates:

  • Compilation speed per phase
  • Correctness of all optimizations
  • Performance improvements

Language Feature Coverage

Data Types

Type Status Tests
int ✓ Complete arithmetic, recursion, loops
bool ✓ Complete booleans, logical operators
string ✓ Complete string_operations

Operators

Category Status Operators
Arithmetic ✓ +, -, *, /, %
Comparison ✓ ==, !=, <, >, <=, >=
Logical ✓ &&, ||, !
Unary ✓ -, !

Control Flow

Feature Status Tests
if/else ✓ if_statement, if_else_statement, if_else_if_else
while ✓ while_loop, while_with_break, while_with_continue
for ✓ for_loop, for_with_break, for_with_continue
break ✓ break_in_nested_loop, nested_loops
continue ✓ while_with_continue, for_with_continue
Nested ✓ nested_loops, nested_for_loops

Functions

Feature Status Tests
Declaration ✓ All function tests
Parameters ✓ 0-6 parameters tested
Recursion ✓ recursive_factorial, fibonacci
Mutual Recursion ✓ mutual_recursion
Return ✓ All function tests

Built-in Functions

Function Status Tests
print() ✓ All tests use print

Test Results

Compilation Status

✓ Basic functionality:  10/10 passing
✓ Functions:           6/6 passing
✓ Control flow:        12/12 passing
✓ Edge cases:          12/12 passing
✓ Error detection:     6/6 passing
─────────────────────────────
✓ TOTAL:               46/46 passing (100%)

Error Detection Validation

Correctly detects:
✓ Undeclared variables
✓ Undefined functions
✓ break outside loop
✓ continue outside loop
✓ Function argument count mismatch
✓ Invalid syntax

Performance

When running all 46 tests:

  • Total Time: ~25-30ms
  • Average per test: ~0.5-0.7ms
  • Lexer: ~0.1-0.3ms
  • Parser: ~0.04-0.1ms
  • Analyzer: ~0.08-0.2ms
  • CodeGen: ~0.02-0.05ms

Adding New Tests

Method 1: Add to test_suite.py

# Add to appropriate list (BASIC_TESTS, FUNCTION_TESTS, etc.)
BASIC_TESTS.append(("test_name", """
fn main() -> int {
    // Test code here
    return 0;
}
"""))

Method 2: Create new .zip file

# Create examples/test_newfeature.zip
# Add to examples directory
# Automatically picked up for testing

Method 3: Create standalone test

from lexer import Lexer
from parser import Parser
from analyzer import Analyzer
from codegen import CodeGenerator

code = """your program here"""
lexer = Lexer(code)
tokens = lexer.tokenize()
parser = Parser(tokens)
ast = parser.parse()
analyzer = Analyzer()
analyzer.analyze(ast)
codegen = CodeGenerator()
asm = codegen.generate(ast)

Continuous Integration

To integrate with CI/CD:

#!/bin/bash
# Run all tests
python test_suite.py || exit 1
python test_optimizations.py || exit 1

# Optional: Compile and link examples
for example in examples/test_*.zip; do
    python src/main.py "$example" -o "${example%.zip}"
done

Test Maintenance

Adding Tests

  1. Identify feature/scenario to test
  2. Write minimal test program
  3. Add to appropriate category list
  4. Run python test_suite.py
  5. Verify test passes

Updating Tests

Tests are independent and can be modified without affecting others.

Debugging Failed Tests

# Manual debugging
from test_suite import compile_program

code = """your program"""
success, error = compile_program(code)
if not success:
    print(f"Error: {error}")

File Structure

compiler/
├── test_suite.py              # Main test suite (46 tests)
├── TEST_CASES.md             # This file
├── test_optimizations.py     # Benchmark suite
├── examples/
│   ├── hello.zip             # Original hello world
│   ├── features.zip          # Feature showcase
│   ├── test_arithmetic.zip
│   ├── test_recursion.zip
│   ├── test_loops.zip
│   ├── test_nested_loops.zip
│   ├── test_strings.zip
│   ├── test_booleans.zip
│   ├── test_functions.zip
│   └── test_mutual_recursion.zip
├── src/
│   ├── lexer.py
│   ├── parser.py
│   ├── analyzer.py
│   ├── codegen.py
│   └── main.py

Summary

The ZIP compiler now has professional-grade testing infrastructure with:

  • ✅ 46 comprehensive test cases (100% passing)
  • ✅ Coverage of all language features
  • ✅ Error detection validation
  • ✅ Performance benchmarking
  • ✅ 8 example programs
  • ✅ Easy extensibility for new tests

The compiler is production-ready with robust validation!

Status: ✅ Complete - All tests passing Last Updated: 2026-04-22 Maintainer: ZIP Compiler Team