pub fn main(world: World) -> Void raises {
    var ok: Bool = true

    let hex_len: Maybe<usize> = std.codec.hexDecodedLen("417a")
    var hex_buf: [2]u8 = [0_u8; 2]
    let hex: Maybe<Span<u8>> = std.codec.hexDecode(hex_buf, "417a")
    let bad_hex: Maybe<usize> = std.codec.hexDecodedLen("41z")
    if !hex_len.has || hex_len.value != 2_usize || !hex.has || !std.mem.eql(hex.value, "Az") || bad_hex.has {
        ok = false
    }

    let b64_len: Maybe<usize> = std.codec.base64DecodedLen("emVybw==")
    var b64_buf: [4]u8 = [0_u8; 4]
    let b64: Maybe<Span<u8>> = std.codec.base64Decode(b64_buf, "emVybw==")
    let bad_b64: Maybe<Span<u8>> = std.codec.base64Decode(b64_buf, "abc")
    var b64_one_buf: [1]u8 = [0_u8; 1]
    var b64_two_buf: [2]u8 = [0_u8; 2]
    let bad_b64_one_pad_bits: Maybe<Span<u8>> = std.codec.base64Decode(b64_one_buf, "AB==")
    let bad_b64_two_pad_bits: Maybe<Span<u8>> = std.codec.base64Decode(b64_two_buf, "AAB=")
    if !b64_len.has || b64_len.value != 4_usize || !b64.has || !std.mem.eql(b64.value, "zero") || bad_b64.has || bad_b64_one_pad_bits.has || bad_b64_two_pad_bits.has {
        ok = false
    }
    let raw_b64_len: Maybe<usize> = std.codec.base64RawDecodedLen("emVybw")
    var raw_b64_buf: [4]u8 = [0_u8; 4]
    let raw_b64: Maybe<Span<u8>> = std.codec.base64RawDecode(raw_b64_buf, "emVybw")
    var raw_b64_out_buf: [8]u8 = [0_u8; 8]
    let raw_b64_out: Maybe<Span<u8>> = std.codec.base64RawEncode(raw_b64_out_buf, "zero")
    let bad_raw_b64: Maybe<Span<u8>> = std.codec.base64RawDecode(raw_b64_buf, "AB")
    var url_b64_buf: [2]u8 = [0_u8; 2]
    let url_b64_len: Maybe<usize> = std.codec.base64UrlDecodedLen("-_8")
    let url_b64: Maybe<Span<u8>> = std.codec.base64UrlDecode(url_b64_buf, "-_8")
    var url_b64_out_buf: [4]u8 = [0_u8; 4]
    let url_b64_out: Maybe<Span<u8>> = std.codec.base64UrlEncode(url_b64_out_buf, "\xfb\xff")
    let bad_url_b64: Maybe<Span<u8>> = std.codec.base64UrlDecode(url_b64_buf, "+/8")
    if std.codec.base64RawEncodedLen(4_usize) != 6_usize || std.codec.base64UrlEncodedLen(2_usize) != 3_usize || !raw_b64_len.has || raw_b64_len.value != 4_usize || !raw_b64.has || !std.mem.eql(raw_b64.value, "zero") || !raw_b64_out.has || !std.mem.eql(raw_b64_out.value, "emVybw") || bad_raw_b64.has || !url_b64_len.has || url_b64_len.value != 2_usize || !url_b64.has || !std.mem.eql(url_b64.value, "\xfb\xff") || !url_b64_out.has || !std.mem.eql(url_b64_out.value, "-_8") || bad_url_b64.has {
        ok = false
    }
    let b32_len: Maybe<usize> = std.codec.base32DecodedLen("PJSXE3Y=")
    var b32_buf: [4]u8 = [0_u8; 4]
    let b32: Maybe<Span<u8>> = std.codec.base32Decode(b32_buf, "PJSXE3Y=")
    var b32_out_buf: [8]u8 = [0_u8; 8]
    let b32_out: Maybe<Span<u8>> = std.codec.base32Encode(b32_out_buf, "zero")
    let raw_b32_len: Maybe<usize> = std.codec.base32RawDecodedLen("PJSXE3Y")
    var raw_b32_buf: [4]u8 = [0_u8; 4]
    let raw_b32: Maybe<Span<u8>> = std.codec.base32RawDecode(raw_b32_buf, "PJSXE3Y")
    var raw_b32_out_buf: [8]u8 = [0_u8; 8]
    let raw_b32_out: Maybe<Span<u8>> = std.codec.base32RawEncode(raw_b32_out_buf, "zero")
    var b32_pair_buf: [2]u8 = [0_u8; 2]
    let b32_pair: Maybe<Span<u8>> = std.codec.base32Decode(b32_pair_buf, "7P7Q====")
    let bad_b32_pad_bits: Maybe<Span<u8>> = std.codec.base32Decode(b32_pair_buf, "AB======")
    if std.codec.base32EncodedLen(4_usize) != 8_usize || std.codec.base32RawEncodedLen(4_usize) != 7_usize || !b32_len.has || b32_len.value != 4_usize || !b32.has || !std.mem.eql(b32.value, "zero") || !b32_out.has || !std.mem.eql(b32_out.value, "PJSXE3Y=") || !raw_b32_len.has || raw_b32_len.value != 4_usize || !raw_b32.has || !std.mem.eql(raw_b32.value, "zero") || !raw_b32_out.has || !std.mem.eql(raw_b32_out.value, "PJSXE3Y") || !b32_pair.has || !std.mem.eql(b32_pair.value, "\xfb\xff") || bad_b32_pad_bits.has {
        ok = false
    }

    let le16: Maybe<u16> = std.codec.readU16Le("AB")
    let be16: Maybe<u16> = std.codec.readU16Be("AB")
    var word_le_buf: [2]u8 = [0_u8; 2]
    var word_be_buf: [2]u8 = [0_u8; 2]
    let word_le: Maybe<Span<u8>> = std.codec.writeU16Le(word_le_buf, 0x4142_u16)
    let word_be: Maybe<Span<u8>> = std.codec.writeU16Be(word_be_buf, 0x4142_u16)
    if !le16.has || le16.value != 0x4241_u16 || !be16.has || be16.value != 0x4142_u16 || !word_le.has || !std.mem.eql(word_le.value, "BA") || !word_be.has || !std.mem.eql(word_be.value, "AB") {
        ok = false
    }

    var dword_le_buf: [4]u8 = [0_u8; 4]
    var dword_be_buf: [4]u8 = [0_u8; 4]
    let dword_le: Maybe<Span<u8>> = std.codec.writeU32Le(dword_le_buf, 0x41424344_u32)
    let dword_be: Maybe<Span<u8>> = std.codec.writeU32Be(dword_be_buf, 0x41424344_u32)
    if !dword_le.has || !dword_be.has {
        ok = false
    }
    if dword_le.has {
        let read_back_le: Maybe<u32> = std.codec.readU32Le(dword_le.value)
        if !read_back_le.has || read_back_le.value != 0x41424344_u32 {
            ok = false
        }
    }
    if dword_be.has {
        let read_back_be: Maybe<u32> = std.codec.readU32Be(dword_be.value)
        if !read_back_be.has || read_back_be.value != 0x41424344_u32 {
            ok = false
        }
    }

    var varint_buf: [5]u8 = [0_u8; 5]
    let varint: Maybe<Span<u8>> = std.codec.varintEncode(varint_buf, 300_u32)
    if !varint.has {
        ok = false
    }
    if varint.has {
        let decoded_varint: Maybe<u32> = std.codec.varintDecode(varint.value)
        if std.mem.len(varint.value) != 2_usize || !decoded_varint.has || decoded_varint.value != 300_u32 {
            ok = false
        }
    }
    let invalid_varint: Maybe<u32> = std.codec.varintDecode("\xff\xff\xff\xff\xff")
    let trailing_varint: Maybe<u32> = std.codec.varintDecode("\xac\x02\x01")
    if invalid_varint.has || trailing_varint.has {
        ok = false
    }

    var percent_buf: [16]u8 = [0_u8; 16]
    let percent: Maybe<Span<u8>> = std.url.percentEncode(percent_buf, "a b/")
    var percent_decode_buf: [8]u8 = [0_u8; 8]
    if !percent.has {
        ok = false
    }
    if percent.has {
        let decoded_percent: Maybe<Span<u8>> = std.url.percentDecode(percent_decode_buf, percent.value)
        if !std.mem.eql(percent.value, "a%20b%2F") || !decoded_percent.has || !std.mem.eql(decoded_percent.value, "a b/") {
            ok = false
        }
    }

    var query_buf: [16]u8 = [0_u8; 16]
    let escaped_query: Maybe<Span<u8>> = std.url.queryEscape(query_buf, "a b+c")
    var query_decode_buf: [8]u8 = [0_u8; 8]
    if !escaped_query.has {
        ok = false
    }
    if escaped_query.has {
        let decoded_query: Maybe<Span<u8>> = std.url.queryUnescape(query_decode_buf, escaped_query.value)
        if !std.mem.eql(escaped_query.value, "a+b%2Bc") || !decoded_query.has || !std.mem.eql(decoded_query.value, "a b+c") {
            ok = false
        }
    }

    let url: Span<u8> = "https://user@example.com:443/path/to?q=zero%20lang&n=42#frag"
    let scheme: Maybe<Span<u8>> = std.url.scheme(url)
    let authority: Maybe<Span<u8>> = std.url.authority(url)
    let host: Maybe<Span<u8>> = std.url.host(url)
    let ipv6_host: Maybe<Span<u8>> = std.url.host("https://[::1]:443/path")
    let malformed_ipv6_host: Maybe<Span<u8>> = std.url.host("https://[::1]extra/path")
    let path: Span<u8> = std.url.path(url)
    let relative_path: Span<u8> = std.url.path("search?q=zero")
    let rootless_scheme_path: Span<u8> = std.url.path("mailto:user@example.com")
    let query: Maybe<Span<u8>> = std.url.query(url)
    let fragment: Maybe<Span<u8>> = std.url.fragment(url)
    let fragment_query: Maybe<Span<u8>> = std.url.query("https://example.com/path#frag?q=1")
    if !scheme.has || !std.mem.eql(scheme.value, "https") || !authority.has || !std.mem.eql(authority.value, "user@example.com:443") || !host.has || !std.mem.eql(host.value, "example.com") || !ipv6_host.has || !std.mem.eql(ipv6_host.value, "[::1]") || malformed_ipv6_host.has || !std.mem.eql(path, "/path/to") || !std.mem.eql(relative_path, "search") || !std.mem.eql(rootless_scheme_path, "user@example.com") || !query.has || !fragment.has || !std.mem.eql(fragment.value, "frag") {
        ok = false
    }
    if query.has {
        let q: Maybe<Span<u8>> = std.url.queryValue(query.value, "q")
        if !q.has || !std.mem.eql(q.value, "zero%20lang") {
            ok = false
        }
        var decoded_q_buf: [16]u8 = [0_u8; 16]
        let decoded_q: Maybe<Span<u8>> = std.url.queryValueDecoded(decoded_q_buf, query.value, "q")
        if !decoded_q.has || !std.mem.eql(decoded_q.value, "zero lang") {
            ok = false
        }
    }
    var decoded_name_buf: [24]u8 = [0_u8; 24]
    let decoded_name: Maybe<Span<u8>> = std.url.queryValueDecoded(decoded_name_buf, "first+name=Ada%2BLovelace&empty=", "first name")
    var decoded_empty_buf: [1]u8 = [0_u8; 1]
    let decoded_empty: Maybe<Span<u8>> = std.url.queryValueDecoded(decoded_empty_buf, "first+name=Ada%2BLovelace&empty=", "empty")
    var decoded_bad_buf: [8]u8 = [0_u8; 8]
    let decoded_bad: Maybe<Span<u8>> = std.url.queryValueDecoded(decoded_bad_buf, "q=%zz", "q")
    if !decoded_name.has || !std.mem.eql(decoded_name.value, "Ada+Lovelace") || !decoded_empty.has || std.mem.len(decoded_empty.value) != 0_usize || decoded_bad.has {
        ok = false
    }
    var query_param_buf: [16]u8 = [0_u8; 16]
    let query_param: Maybe<Span<u8>> = std.url.writeQueryParam(query_param_buf, "q", "zero lang")
    var append_buf: [48]u8 = [0_u8; 48]
    var appended: Maybe<Span<u8>> = null
    if query_param.has {
        appended = std.url.appendQuery(append_buf, "https://example.com/path", query_param.value)
    }
    if !appended.has || !std.mem.eql(appended.value, "https://example.com/path?q=zero+lang") {
        ok = false
    }
    var built_url_buf: [48]u8 = [0_u8; 48]
    let built_url: Maybe<Span<u8>> = std.url.writeUrl(built_url_buf, "https", "example.com", "path")
    var built_query_url_buf: [64]u8 = [0_u8; 64]
    var built_query_url: Maybe<Span<u8>> = null
    if built_url.has && query_param.has {
        built_query_url = std.url.appendQuery(built_query_url_buf, built_url.value, query_param.value)
    }
    var built_fragment_buf: [72]u8 = [0_u8; 72]
    var built_fragment: Maybe<Span<u8>> = null
    if built_query_url.has {
        built_fragment = std.url.appendFragment(built_fragment_buf, built_query_url.value, "section-1")
    }
    if !built_url.has || !std.mem.eql(built_url.value, "https://example.com/path") || !built_query_url.has || !std.mem.eql(built_query_url.value, "https://example.com/path?q=zero+lang") || !built_fragment.has || !std.mem.eql(built_fragment.value, "https://example.com/path?q=zero+lang#section-1") {
        ok = false
    }
    var append_fragment_buf: [56]u8 = [0_u8; 56]
    var appended_fragment: Maybe<Span<u8>> = null
    if query_param.has {
        appended_fragment = std.url.appendQuery(append_fragment_buf, "https://example.com/path#frag", query_param.value)
    }
    if fragment_query.has || !appended_fragment.has || !std.mem.eql(appended_fragment.value, "https://example.com/path?q=zero+lang#frag") {
        ok = false
    }
    var form_name_buf: [32]u8 = [0_u8; 32]
    let form_name: Maybe<Span<u8>> = std.url.writeFormField(form_name_buf, "first name", "Ada Lovelace")
    var form_note_buf: [24]u8 = [0_u8; 24]
    let form_note: Maybe<Span<u8>> = std.url.writeFormField(form_note_buf, "note", "a+b&c")
    var form_buf: [64]u8 = [0_u8; 64]
    var form: Maybe<Span<u8>> = null
    if form_name.has && form_note.has {
        form = std.url.appendFormField(form_buf, form_name.value, form_note.value)
    }
    var form_single_buf: [32]u8 = [0_u8; 32]
    var form_single: Maybe<Span<u8>> = null
    if form_note.has {
        form_single = std.url.appendFormField(form_single_buf, "", form_note.value)
    }
    var form_value_name_buf: [24]u8 = [0_u8; 24]
    var form_value_name: Maybe<Span<u8>> = null
    var form_value_note_buf: [16]u8 = [0_u8; 16]
    var form_value_note: Maybe<Span<u8>> = null
    if form.has {
        form_value_name = std.url.formValue(form_value_name_buf, form.value, "first name")
        form_value_note = std.url.formValue(form_value_note_buf, form.value, "note")
    }
    var form_tiny_buf: [4]u8 = [0_u8; 4]
    var form_tiny: Maybe<Span<u8>> = null
    if form_name.has && form_note.has {
        form_tiny = std.url.appendFormField(form_tiny_buf, form_name.value, form_note.value)
    }
    if !form_name.has || !std.mem.eql(form_name.value, "first+name=Ada+Lovelace") || !form_note.has || !std.mem.eql(form_note.value, "note=a%2Bb%26c") || !form.has || !std.mem.eql(form.value, "first+name=Ada+Lovelace&note=a%2Bb%26c") || !form_single.has || !std.mem.eql(form_single.value, "note=a%2Bb%26c") || !form_value_name.has || !std.mem.eql(form_value_name.value, "Ada Lovelace") || !form_value_note.has || !std.mem.eql(form_value_note.value, "a+b&c") || form_tiny.has {
        ok = false
    }

    let json: Span<u8> = "{\"name\":\"zero\\nlang\",\"count\":42,\"ok\":true,\"nested\":{\"x\":1},\"list\":[1,2]}"
    if std.json.errorNone() != 0_u32 || std.json.errorInvalid() != 1_u32 || std.json.errorTrailing() != 2_u32 {
        ok = false
    }
    if !std.mem.eql(std.json.errorName(std.json.errorNone()), "ok") || !std.mem.eql(std.json.errorName(std.json.errorInvalid()), "invalid") || !std.mem.eql(std.json.errorName(std.json.errorTrailing()), "trailing") || !std.mem.eql(std.json.errorName(99_u32), "unknown") {
        ok = false
    }
    if !std.mem.eql(std.json.errorExpected(std.json.errorNone()), "none") || !std.mem.eql(std.json.errorExpected(std.json.errorInvalid()), "valid-json") || !std.mem.eql(std.json.errorExpected(std.json.errorTrailing()), "end-of-input") || !std.mem.eql(std.json.errorExpected(99_u32), "unknown") {
        ok = false
    }
    let dynamic_ok_status: u32 = std.json.validateError(json)
    let dynamic_invalid_status: u32 = std.json.validateError("{")
    let dynamic_trailing_status: u32 = std.json.validateError("{} x")
    let dynamic_unknown_status: u32 = dynamic_trailing_status + 97_u32
    if !std.mem.eql(std.json.errorName(dynamic_ok_status), "ok") || !std.mem.eql(std.json.errorExpected(dynamic_ok_status), "none") || !std.mem.eql(std.json.errorName(dynamic_unknown_status), "unknown") || !std.mem.eql(std.json.errorExpected(dynamic_unknown_status), "unknown") {
        ok = false
    }
    if !std.mem.eql(std.json.errorName(dynamic_invalid_status), "invalid") || !std.mem.eql(std.json.errorExpected(dynamic_invalid_status), "valid-json") || !std.mem.eql(std.json.errorName(dynamic_trailing_status), "trailing") || !std.mem.eql(std.json.errorExpected(dynamic_trailing_status), "end-of-input") {
        ok = false
    }
    if std.json.validateError(json) != std.json.errorNone() || std.json.validateError("\"\\u20ac\"") != std.json.errorNone() || std.json.validateError("\"\\ud834\\udd1e\"") != std.json.errorNone() || std.json.validateError("\"\\ud800\"") != std.json.errorInvalid() || std.json.validateError("\"\xff\"") != std.json.errorInvalid() || std.json.validateError("{") != std.json.errorInvalid() || std.json.validateError("{} x") != std.json.errorTrailing() || std.json.validateError("[1,]") != std.json.errorInvalid() || std.json.validateError("{\"a\":1,}") != std.json.errorInvalid() {
        ok = false
    }
    let invalid_json: Span<u8> = "{\n  \"ok\": tru\n}"
    let trailing_json: Span<u8> = "{} x"
    var json_location_buf: [24]u8 = [0_u8; 24]
    let json_location: Maybe<Span<u8>> = std.diag.formatOffsetLocation(json_location_buf, "config.json", invalid_json, std.json.errorOffset(invalid_json))
    if std.json.errorOffset(json) != std.mem.len(json) || std.json.errorOffset(invalid_json) != 13 || std.json.errorLine(invalid_json) != 2 || std.json.errorColumn(invalid_json) != 12 || !json_location.has || !std.mem.eql(json_location.value, "config.json:2:12") || std.json.errorOffset(trailing_json) != 3 || std.json.errorLine(trailing_json) != 1 || std.json.errorColumn(trailing_json) != 4 || std.json.errorOffset("[1,]") != 3 || std.json.errorOffset("{\"a\":1,}") != 7 {
        ok = false
    }
    let count_field: Maybe<Span<u8>> = std.json.field(json, "count")
    let count: Maybe<u32> = std.json.u32(json, "count")
    let bool_value: Maybe<Bool> = std.json.bool(json, "ok")
    var name_buf: [16]u8 = [0_u8; 16]
    let name: Maybe<Span<u8>> = std.json.string(name_buf, json, "name")
    let malformed_count: Maybe<u32> = std.json.u32("{\"count\":42", "count")
    let malformed_field: Maybe<Span<u8>> = std.json.field("{\"name\":\"zero\",", "name")
    if !count_field.has || !std.mem.eql(count_field.value, "42") || !count.has || count.value != 42_u32 || !bool_value.has || !bool_value.value || !name.has || !std.mem.eql(name.value, "zero\nlang") || malformed_count.has || malformed_field.has {
        ok = false
    }

    var decoded_string_buf: [8]u8 = [0_u8; 8]
    let decoded_string: Maybe<Span<u8>> = std.json.stringDecode(decoded_string_buf, "\"a\\\"b\"")
    var decoded_unicode_buf: [8]u8 = [0_u8; 8]
    let decoded_unicode: Maybe<Span<u8>> = std.json.stringDecode(decoded_unicode_buf, "\"\\u20ac\"")
    var decoded_pair_buf: [8]u8 = [0_u8; 8]
    let decoded_pair: Maybe<Span<u8>> = std.json.stringDecode(decoded_pair_buf, "\"\\ud834\\udd1e\"")
    var invalid_string_buf: [8]u8 = [0_u8; 8]
    let invalid_string: Maybe<Span<u8>> = std.json.stringDecode(invalid_string_buf, "\"\xff\"")
    let unicode_key_field: Maybe<Span<u8>> = std.json.field("{\"\\u20ac\":1}", "\xe2\x82\xac")
    var string_out_buf: [16]u8 = [0_u8; 16]
    let string_out: Maybe<Span<u8>> = std.json.writeStringBytes(string_out_buf, "a\nb")
    var invalid_out_buf: [8]u8 = [0_u8; 8]
    let invalid_out: Maybe<Span<u8>> = std.json.writeStringBytes(invalid_out_buf, "\xff")
    if !decoded_string.has || !std.mem.eql(decoded_string.value, "a\"b") || !decoded_unicode.has || !std.mem.eql(decoded_unicode.value, "\xe2\x82\xac") || !decoded_pair.has || !std.mem.eql(decoded_pair.value, "\xf0\x9d\x84\x9e") || invalid_string.has || !unicode_key_field.has || !std.mem.eql(unicode_key_field.value, "1") || !string_out.has || !std.mem.eql(string_out.value, "\"a\\nb\"") || invalid_out.has {
        ok = false
    }

    var object_string_buf: [24]u8 = [0_u8; 24]
    let object_string: Maybe<Span<u8>> = std.json.writeObject1String(object_string_buf, "name", "zero")
    var object_u32_buf: [16]u8 = [0_u8; 16]
    let object_u32: Maybe<Span<u8>> = std.json.writeObject1U32(object_u32_buf, "count", 42_u32)
    var object_bool_buf: [16]u8 = [0_u8; 16]
    let object_bool: Maybe<Span<u8>> = std.json.writeObject1Bool(object_bool_buf, "ok", true)
    var raw_user_field_buf: [48]u8 = [0_u8; 48]
    let raw_user_field: Maybe<Span<u8>> = std.json.writeFieldRaw(raw_user_field_buf, "user", "{\"name\":\"zero\"}")
    var raw_tags_field_buf: [48]u8 = [0_u8; 48]
    let raw_tags_field: Maybe<Span<u8>> = std.json.writeFieldRaw(raw_tags_field_buf, "tags", "[\"api\",true]")
    var object_raw_buf: [80]u8 = [0_u8; 80]
    var object_raw: Maybe<Span<u8>> = null
    if raw_user_field.has && raw_tags_field.has {
        object_raw = std.json.writeObject2Fields(object_raw_buf, raw_user_field.value, raw_tags_field.value)
    }
    var name_field_buf: [32]u8 = [0_u8; 32]
    let name_field: Maybe<Span<u8>> = std.json.writeFieldString(name_field_buf, "name", "zero\nlang")
    var role_field_buf: [24]u8 = [0_u8; 24]
    let role_field: Maybe<Span<u8>> = std.json.writeFieldString(role_field_buf, "role", "agent")
    var object_strings_buf: [64]u8 = [0_u8; 64]
    var object_strings: Maybe<Span<u8>> = null
    if name_field.has && role_field.has {
        object_strings = std.json.writeObject2Fields(object_strings_buf, name_field.value, role_field.value)
    }
    var object_strings_direct_buf: [64]u8 = [0_u8; 64]
    var object_strings_direct: Maybe<Span<u8>> = null
    if role_field.has {
        object_strings_direct = std.json.writeObject2StringField(object_strings_direct_buf, "name", "zero\nlang", role_field.value)
    }
    var name_plain_field_buf: [24]u8 = [0_u8; 24]
    let name_plain_field: Maybe<Span<u8>> = std.json.writeFieldString(name_plain_field_buf, "name", "zero")
    var count_json_field_buf: [24]u8 = [0_u8; 24]
    let count_json_field: Maybe<Span<u8>> = std.json.writeFieldU32(count_json_field_buf, "count", 42_u32)
    var ok_field_buf: [16]u8 = [0_u8; 16]
    let ok_field: Maybe<Span<u8>> = std.json.writeFieldBool(ok_field_buf, "ok", true)
    var object_string_u32_buf: [48]u8 = [0_u8; 48]
    var object_string_u32: Maybe<Span<u8>> = null
    if name_plain_field.has && count_json_field.has {
        object_string_u32 = std.json.writeObject2Fields(object_string_u32_buf, name_plain_field.value, count_json_field.value)
    }
    var object_string_u32_direct_buf: [48]u8 = [0_u8; 48]
    var object_string_u32_direct: Maybe<Span<u8>> = null
    if count_json_field.has {
        object_string_u32_direct = std.json.writeObject2StringField(object_string_u32_direct_buf, "name", "zero", count_json_field.value)
    }
    var object_string_bool_buf: [48]u8 = [0_u8; 48]
    var object_string_bool: Maybe<Span<u8>> = null
    if name_plain_field.has && ok_field.has {
        object_string_bool = std.json.writeObject2Fields(object_string_bool_buf, name_plain_field.value, ok_field.value)
    }
    var object_string_bool_direct_buf: [48]u8 = [0_u8; 48]
    var object_string_bool_direct: Maybe<Span<u8>> = null
    if ok_field.has {
        object_string_bool_direct = std.json.writeObject2StringField(object_string_bool_direct_buf, "name", "zero", ok_field.value)
    }
    var object_u32_bool_buf: [32]u8 = [0_u8; 32]
    var object_u32_bool: Maybe<Span<u8>> = null
    if count_json_field.has && ok_field.has {
        object_u32_bool = std.json.writeObject2Fields(object_u32_bool_buf, count_json_field.value, ok_field.value)
    }
    var object_u32_bool_direct_buf: [32]u8 = [0_u8; 32]
    var object_u32_bool_direct: Maybe<Span<u8>> = null
    if ok_field.has {
        object_u32_bool_direct = std.json.writeObject2U32Field(object_u32_bool_direct_buf, "count", 42_u32, ok_field.value)
    }
    var object_bool_u32_direct_buf: [32]u8 = [0_u8; 32]
    var object_bool_u32_direct: Maybe<Span<u8>> = null
    if count_json_field.has {
        object_bool_u32_direct = std.json.writeObject2BoolField(object_bool_u32_direct_buf, "ok", true, count_json_field.value)
    }
    var object_bad_raw_buf: [48]u8 = [0_u8; 48]
    let object_bad_raw: Maybe<Span<u8>> = std.json.writeFieldRaw(object_bad_raw_buf, "bad", "{")
    var object_small_buf: [12]u8 = [0_u8; 12]
    var object_small: Maybe<Span<u8>> = null
    if name_plain_field.has && role_field.has {
        object_small = std.json.writeObject2Fields(object_small_buf, name_plain_field.value, role_field.value)
    }
    var object2_direct_small_buf: [16]u8 = [0_u8; 16]
    var object2_direct_small: Maybe<Span<u8>> = null
    if count_json_field.has {
        object2_direct_small = std.json.writeObject2StringField(object2_direct_small_buf, "name", "zero", count_json_field.value)
    }
    if !object_string.has || !std.mem.eql(object_string.value, "{\"name\":\"zero\"}") || !object_u32.has || !std.mem.eql(object_u32.value, "{\"count\":42}") || !object_bool.has || !std.mem.eql(object_bool.value, "{\"ok\":true}") || !raw_user_field.has || !raw_tags_field.has || !object_raw.has || !std.mem.eql(object_raw.value, "{\"user\":{\"name\":\"zero\"},\"tags\":[\"api\",true]}") || !name_field.has || !role_field.has || !object_strings.has || !std.mem.eql(object_strings.value, "{\"name\":\"zero\\nlang\",\"role\":\"agent\"}") || !object_strings_direct.has || !std.mem.eql(object_strings_direct.value, "{\"name\":\"zero\\nlang\",\"role\":\"agent\"}") || !name_plain_field.has || !count_json_field.has || !ok_field.has || !object_string_u32.has || !std.mem.eql(object_string_u32.value, "{\"name\":\"zero\",\"count\":42}") || !object_string_u32_direct.has || !std.mem.eql(object_string_u32_direct.value, "{\"name\":\"zero\",\"count\":42}") || !object_string_bool.has || !std.mem.eql(object_string_bool.value, "{\"name\":\"zero\",\"ok\":true}") || !object_string_bool_direct.has || !std.mem.eql(object_string_bool_direct.value, "{\"name\":\"zero\",\"ok\":true}") || !object_u32_bool.has || !std.mem.eql(object_u32_bool.value, "{\"count\":42,\"ok\":true}") || !object_u32_bool_direct.has || !std.mem.eql(object_u32_bool_direct.value, "{\"count\":42,\"ok\":true}") || !object_bool_u32_direct.has || !std.mem.eql(object_bool_u32_direct.value, "{\"ok\":true,\"count\":42}") || object_bad_raw.has || object_small.has || object2_direct_small.has {
        ok = false
    }
    var array_strings_buf: [32]u8 = [0_u8; 32]
    let array_strings: Maybe<Span<u8>> = std.json.writeArray2Strings(array_strings_buf, "zero\nlang", "agent")
    var array_u32_buf: [16]u8 = [0_u8; 16]
    let array_u32: Maybe<Span<u8>> = std.json.writeArray2U32(array_u32_buf, 7_u32, 42_u32)
    var array_bools_buf: [16]u8 = [0_u8; 16]
    let array_bools: Maybe<Span<u8>> = std.json.writeArray2Bools(array_bools_buf, true, false)
    var array_small_buf: [4]u8 = [0_u8; 4]
    let array_small: Maybe<Span<u8>> = std.json.writeArray2Strings(array_small_buf, "zero", "agent")
    if !array_strings.has || !std.mem.eql(array_strings.value, "[\"zero\\nlang\",\"agent\"]") || !array_u32.has || !std.mem.eql(array_u32.value, "[7,42]") || !array_bools.has || !std.mem.eql(array_bools.value, "[true,false]") || array_small.has {
        ok = false
    }
    if object_raw.has && std.json.validateError(object_raw.value) != std.json.errorNone() {
        ok = false
    }

    if ok {
        check world.out.write("std codec json url ok\n")
        return
    }
    check world.err.write("std codec json url failed\n")
}