vercel-labs--zerolang/conformance/native/pass/std-testing-log.0

fn testing_helpers_ok() -> Bool {
    let bytes: Span<u8> = "zerolang"
    if !std.testing.isTrue(true) {
        return false
    }
    if !std.testing.isFalse(false) {
        return false
    }
    if !std.testing.equalBool(true, true) {
        return false
    }
    if !std.testing.equalUsize(std.mem.len(bytes), 8) {
        return false
    }
    if !std.testing.equalU32(42_u32, 42_u32) {
        return false
    }
    if !std.testing.equalI32(-7, -7) {
        return false
    }
    if !std.testing.equalBytes("zero", "zero") {
        return false
    }
    if !std.testing.containsBytes(bytes, "lang") {
        return false
    }
    if !std.testing.startsWith(bytes, "zero") {
        return false
    }
    if !std.testing.endsWith(bytes, "lang") {
        return false
    }
    if !std.testing.notEqualBytes("zero", "lang") {
        return false
    }
    let diff: Maybe<usize> = std.testing.diffIndexBytes("zero", "zeta")
    if !diff.has || diff.value != 2 {
        return false
    }
    let same: Maybe<usize> = std.testing.diffIndexBytes("zero", "zero")
    if same.has {
        return false
    }
    if !std.testing.jsonFieldEquals("{\"ok\":true,\"count\":2}", "count", "2") {
        return false
    }
    if !std.testing.jsonPathEquals("{\"user\":{\"name\":\"zero\"}}", "user.name", "\"zero\"") {
        return false
    }
    var case_storage: [32]u8 = [0_u8; 32]
    let case_name: Maybe<Span<u8>> = std.testing.caseName(case_storage, "json", 3)
    if !case_name.has || !std.testing.equalBytes(case_name.value, "json[3]") {
        return false
    }
    return true
}

fn log_message_ok() -> Bool {
    var storage: [128]u8 = [0_u8; 128]
    let entry: Maybe<Span<u8>> = std.log.message(storage, "info", "agent ready")
    if entry.has {
        if !std.testing.startsWith(entry.value, "{\"level\":\"info\"") {
            return false
        }
        if !std.testing.containsBytes(entry.value, "\"message\":\"agent ready\"") {
            return false
        }
        return std.testing.endsWith(entry.value, "}\n")
    }
    return false
}

fn log_key_value_ok() -> Bool {
    var storage: [128]u8 = [0_u8; 128]
    let entry: Maybe<Span<u8>> = std.log.keyValue(storage, "info", "event", "startup")
    if entry.has {
        if !std.testing.startsWith(entry.value, "{\"level\":\"info\"") {
            return false
        }
        if !std.testing.containsBytes(entry.value, "\"key\":\"event\"") {
            return false
        }
        return std.testing.containsBytes(entry.value, "\"value\":\"startup\"")
    }
    return false
}

fn log_message_field_ok() -> Bool {
    var storage: [160]u8 = [0_u8; 160]
    var field_storage: [64]u8 = [0_u8; 64]
    let field: Maybe<Span<u8>> = std.log.stringField(field_storage, "route", "/health")
    if field.has {
        let entry: Maybe<Span<u8>> = std.log.messageField(storage, std.log.levelInfo(), "request handled", field.value)
        if !entry.has {
            return false
        }
        if !std.testing.startsWith(entry.value, "{\"level\":\"info\"") {
            return false
        }
        if !std.testing.containsBytes(entry.value, "\"message\":\"request handled\"") {
            return false
        }
        return std.testing.containsBytes(entry.value, "\"route\":\"/health\"")
    }
    return false
}

fn log_redacted_ok() -> Bool {
    var storage: [128]u8 = [0_u8; 128]
    let entry: Maybe<Span<u8>> = std.log.redacted(storage, std.log.levelWarn(), "authorization")
    if entry.has {
        if !std.testing.containsBytes(entry.value, "\"key\":\"authorization\"") {
            return false
        }
        return std.testing.containsBytes(entry.value, "\"redacted\":true")
    }
    return false
}

fn log_level_names_ok() -> Bool {
    var debug_storage: [96]u8 = [0_u8; 96]
    var error_storage: [96]u8 = [0_u8; 96]
    let debug_entry: Maybe<Span<u8>> = std.log.message(debug_storage, std.log.levelDebug(), "debug path")
    let error_entry: Maybe<Span<u8>> = std.log.message(error_storage, std.log.levelError(), "error path")
    if !debug_entry.has || !error_entry.has {
        return false
    }
    return std.testing.containsBytes(debug_entry.value, "\"level\":\"debug\"") && std.testing.containsBytes(error_entry.value, "\"level\":\"error\"")
}

pub fn main(world: World) -> Void raises {
    if testing_helpers_ok() && log_message_ok() && (log_key_value_ok() && log_message_field_ok()) && (log_redacted_ok() && log_level_names_ok()) {
        check world.out.write("std testing log ok\n")
    } else {
        check world.out.write("std testing log failed\n")
    }
}