测试与泄漏检测

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" {
    // 使用测试分配器，它跟踪分配并检测泄漏
    const allocator = std.testing.allocator;

    // 在堆上分配64字节缓冲区
    const buf = try allocator.alloc(u8, 64);
    // 安排在作用域退出时释放（确保清理）
    defer allocator.free(buf);

    // 用0xAA模式填充缓冲区以演示用法
    for (buf) |*b| b.* = 0xAA;

    // 当测试退出时，defer运行allocator.free(buf)
    // 测试分配器验证所有分配都被释放
}

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.