Test Chapter Organization

​

Chapter Progression

writing-a-c-compiler-tests/
└── tests/
    ├── chapter_1/
    │   ├── valid/
    │   ├── invalid_parse/
    │   └── invalid_semantics/
    ├── chapter_2/
    │   ├── valid/
    │   └── invalid_parse/
    └── ...

​

Test Categories

​

Valid Tests (valid/)

• Compile successfully through all stages
• Execute and return the expected exit code
• Produce the expected standard output (if specified)

// valid/return_2.c
int main(void) {
    return 2;
}

{
  "chapter_1/valid/return_2.c": {
    "return_code": 2
  }
}

​

Invalid Tests

• invalid_parse/ - Lexical or syntactic errors
• invalid_tacky/ - Errors during lowering to intermediate representation
• invalid_semantics/ - Semantic analysis errors
• invalid_codegen/ - Code generation errors
• invalid_types/ - Type checking errors (in later chapters)

​

Chapter Overview

​

Chapters 1-10: Core Language Features

• Basic program structure
• Return statements
• Integer literals
• Tests: Simple programs that return integer constants

• Negation (-)
• Bitwise complement (~)
• Logical negation (!)
• Tests: Expressions with unary operators

• Addition and subtraction
• Multiplication and division
• Modulo
• Tests: Arithmetic expressions with operator precedence

• Comparison operators (<, >, <=, >=, ==, !=)
• Logical operators (&&, ||)
• Short-circuit evaluation
• Tests: Boolean expressions and comparisons

• Variable declarations
• Assignment statements
• Identifier resolution
• Tests: Programs using local variables

• If statements
• Conditional expressions (ternary operator)
• Block statements
• Tests: Control flow with conditionals

• Compound operators (+=, -=, *=, /=, %=)
• Tests: Assignment operators with side effects

• While loops
• Do-while loops
• For loops
• Break and continue statements
• Tests: Iterative control flow

• Function declarations
• Function definitions
• Function calls
• Parameter passing
• Tests: Multi-function programs

• Global variables
• Static variables
• Storage class specifiers
• Tests: Variable scoping and lifetime

​

Chapters 11-18: Advanced Features

• long type
• Type conversions
• Tests: 64-bit integer arithmetic

• unsigned type specifier
• Signed/unsigned conversions
• Tests: Unsigned arithmetic and wrap-around

• double type
• Floating-point arithmetic
• Type conversions with floating-point
• Tests: Floating-point expressions

• Pointer types
• Address-of operator (&)
• Indirection operator (*)
• Tests: Pointer arithmetic and dereferencing

• Array declarations
• Array subscripting
• Array/pointer relationship
• Tests: Array access and manipulation

• String literals
• Character arrays
• String manipulation
• Tests: String operations

• Structure types
• Member access (. and ->)
• Structure assignment
• Tests: Complex data structures

• Function pointers
• Void pointers
• Pointer conversions
• Tests: Advanced pointer usage

​

Chapter 19: Optimizations

• Constant folding
• Dead code elimination
• Copy propagation
• Common subexpression elimination

• Preserve program semantics
• Improve code quality
• Handle edge cases correctly

​

Chapter 20: Register Allocation

• Register allocation strategies
• Spilling to memory
• Register coalescing

• Generates efficient code
• Handles register pressure
• Produces correct results with limited registers

​

Test Naming Convention

• chapter_1::valid::return_2
• chapter_3::invalid_parse::malformed_paren
• chapter_5::valid::multiple_vars
• chapter_6::invalid_semantics::undeclared_var

• Easy filtering by chapter: chapter_3
• Easy filtering by kind: ::valid::
• Easy filtering by feature: return

​

Chapter Configuration

// In integration.rs
const MAX_CHAPTER: u32 = 6;

let ignored = test.chapter > MAX_CHAPTER || ignored.contains(&test.name.as_str());
let trial = test.trial().with_ignored_flag(ignored);

• Progressive development (implement features chapter by chapter)
• CI to run only completed chapters
• Development testing of future chapters with --ignored

​

Feature Dependencies

• Chapter 5 (variables) requires chapters 1-4 (expressions)
• Chapter 6 (conditionals) requires chapter 5 (variables)
• Chapter 8 (loops) requires chapter 6 (conditionals)
• Chapter 9 (functions) requires chapter 8 (loops)
• Chapter 14 (pointers) requires chapters 11-13 (type system)

​

Extra Credit Features

• Bitwise operators (&, |, ^, <<, >>)
• Compound assignment with bitwise operators
• Increment/decrement operators (++, --)
• Goto statements and labels
• Switch statements
• NaN handling for floating-point
• Union types

config.extra_credit = ExtraCreditFlags::BITWISE | ExtraCreditFlags::COMPOUND;

​

Expected Results

{
  "chapter_1/valid/return_0.c": {
    "return_code": 0
  },
  "chapter_1/valid/return_2.c": {
    "return_code": 2
  },
  "chapter_3/valid/add.c": {
    "return_code": 5
  }
}

{
  "chapter_16/valid/hello.c": {
    "return_code": 0,
    "stdout": "Hello, World!\n"
  }
}

​

Running Chapter Tests

​

Run a Single Chapter

cargo test -p integration-tests --test integration -- chapter_1

​

Run Multiple Chapters

cargo test -p integration-tests --test integration -- 'chapter_[12]'

​

Run Chapters Beyond the Cap

# Run all ignored tests (chapters > MAX_CHAPTER)
cargo test -p integration-tests --test integration -- --ignored

# Run specific ignored chapter
cargo test -p integration-tests --test integration -- chapter_10 --ignored

​

Run Only Valid Tests for a Chapter

cargo test -p integration-tests --test integration -- chapter_3::valid

​

Run Only Invalid Tests for a Chapter

cargo test -p integration-tests --test integration -- chapter_5::invalid