Testing & Leak Detection

const std = @import("std");

/// Performs exact integer division, returning an error if the divisor is zero.
/// This function demonstrates error handling in a testable way.
fn divExact(a: i32, b: i32) !i32 {
    // Guard clause: check for division by zero before attempting division
    if (b == 0) return error.DivideByZero;
    // Safe to divide: use @divTrunc for truncating integer division
    return @divTrunc(a, b);
}

test "boolean and equality expectations" {
    // Test basic boolean expression using expect
    // expect() returns an error if the condition is false
    try std.testing.expect(2 + 2 == 4);
    
    // Test type-safe equality with expectEqual
    // Both arguments must be the same type; here we explicitly cast to u8
    try std.testing.expectEqual(@as(u8, 42), @as(u8, 42));
}

test "string equality (bytes)" {
    // Define expected string as a slice of const bytes
    const expected: []const u8 = "hello";
    
    // Create actual string via compile-time concatenation
    // The ++ operator concatenates string literals at compile time
    const actual: []const u8 = "he" ++ "llo";
    
    // Use expectEqualStrings for slice comparison
    // This compares the content of the slices, not just the pointer addresses
    try std.testing.expectEqualStrings(expected, actual);
}

test "expecting an error" {
    // Test that divExact returns the expected error when dividing by zero
    // expectError() succeeds if the function returns the specified error
    try std.testing.expectError(error.DivideByZero, divExact(1, 0));
    
    // Test successful division path
    // We use 'try' to unwrap the success value, then expectEqual to verify it
    // If divExact returns an error here, the test will fail
    try std.testing.expectEqual(@as(i32, 3), try divExact(9, 3));
}

const std = @import("std");

// This test intentionally leaks to demonstrate the testing allocator's leak detection.
// Do NOT copy this pattern into real code; see leak_demo_fix.zig for the fix.

test "leak detection catches a missing free" {
    const allocator = std.testing.allocator;

    // Intentionally leak this allocation by not freeing it.
    const buf = try allocator.alloc(u8, 64);

    // Touch the memory so optimizers can't elide the allocation.
    for (buf) |*b| b.* = 0xAA;

    // No free on purpose:
    // allocator.free(buf);
}

const std = @import("std");

test "no leak when freeing properly" {
    // Use the testing allocator, which tracks allocations and detects leaks
    const allocator = std.testing.allocator;

    // Allocate a 64-byte buffer on the heap
    const buf = try allocator.alloc(u8, 64);
    // Schedule deallocation to happen at scope exit (ensures cleanup)
    defer allocator.free(buf);

    // Fill the buffer with 0xAA pattern to demonstrate usage
    for (buf) |*b| b.* = 0xAA;
    
    // When the test exits, defer runs allocator.free(buf)
    // The testing allocator verifies all allocations were freed
}

const std = @import("std");

fn testImplGood(allocator: std.mem.Allocator, length: usize) !void {
    const a = try allocator.alloc(u8, length);
    defer allocator.free(a);
    const b = try allocator.alloc(u8, length);
    defer allocator.free(b);
}

// No "bad" implementation here; see leak_demo_fail.zig for a dedicated failing example.

test "OOM injection: good implementation is leak-free" {
    const allocator = std.testing.allocator;
    try std.testing.checkAllAllocationFailures(allocator, testImplGood, .{32});
}

// Intentionally not included: a "bad" implementation under checkAllAllocationFailures
// will cause the test runner to fail due to leak logging, even if you expect the error.
// See leak_demo_fail.zig for a dedicated failing example.