测试与泄漏检测

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
    // 可以安全除法：使用 @divTrunc 进行截断整数除法
    return @divTrunc(a, b);
}

test "boolean and equality expectations" {
    // Test basic boolean expression using expect
    // expect() returns an error if the condition is false
    // 使用 expect 测试基本布尔表达式
    // 如果条件为假，expect() 返回错误
    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
    // 使用 expectEqual 测试类型安全相等性
    // 两个参数必须是相同类型；这里我们显式转换为 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 字节切片
    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
    // 使用 expectEqualStrings 进行切片比较
    // 这比较切片的内容，而不仅仅是指针地址
    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
    // 测试 divExact 在除以零时返回期望的错误
    // 如果函数返回指定的错误，expectError() 成功
    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' 来解包成功值，然后使用 expectEqual 验证它
    // 如果 divExact 在这里返回错误，测试将失败
    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.
// 此测试故意泄漏以演示测试分配器的泄漏检测。
// 不要将此模式复制到真实代码中；有关修复方法，请参阅 leak_demo_fix.zig。

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
    // 在堆上分配 64 字节缓冲区
    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
    // 用 0xAA 模式填充缓冲区以演示用法
    for (buf) |*b| b.* = 0xAA;

    // When the test exits, defer runs allocator.free(buf)
    // The testing allocator verifies all allocations were freed
    // 当测试退出时，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.
// 此处没有"坏"实现；有关专门的失败示例，请参阅 leak_demo_fail.zig。

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.
// 故意不包含：在 checkAllAllocationFailures 下的"坏"实现
// 将导致测试运行器因泄漏日志而失败，即使你期望错误。
// 有关专门的失败示例，请参阅 leak_demo_fail.zig。