vercel-labs--zerolang/conformance/native/pass/std-http-api-helpers.0

export c fn main() -> i32 {
    if !std.http.statusIsInformational(100_u16) || !std.http.statusIsSuccess(201_u16) || !std.http.statusIsRedirect(302_u16) || !std.http.statusIsClientError(404_u16) || !std.http.statusIsServerError(503_u16) {
        return 13
    }
    if !std.mem.eql(std.http.statusReason(404_u16), "Not Found") {
        return 14
    }
    var request_buf: [256]u8 = [0_u8; 256]
    let request: Maybe<Span<u8>> = std.http.writeJsonRequest(request_buf, "POST https://example.com/api?name=zero", "{\"ping\":1}")
    if !request.has {
        return 15
    }
    let method: Maybe<Span<u8>> = std.http.requestMethodName(request.value)
    let target: Maybe<Span<u8>> = std.http.requestTarget(request.value)
    let path: Maybe<Span<u8>> = std.http.requestPath(request.value)
    let query: Maybe<Span<u8>> = std.http.requestQuery(request.value)
    let content_type: Maybe<Span<u8>> = std.http.requestHeader(request.value, "content-type")
    let body: Maybe<Span<u8>> = std.http.requestBody(request.value)
    if !method.has || !std.mem.eql(method.value, "POST") {
        return 16
    }
    if !target.has || !std.mem.eql(target.value, "https://example.com/api?name=zero") {
        return 17
    }
    if !path.has || !std.mem.eql(path.value, "/api") {
        return 18
    }
    if !query.has || !std.mem.eql(query.value, "name=zero") {
        return 19
    }
    if !content_type.has || !std.mem.eql(content_type.value, "application/json") {
        return 20
    }
    if !body.has || !std.mem.eql(body.value, "{\"ping\":1}") {
        return 21
    }
    let name: Maybe<Span<u8>> = std.url.queryValue(query.value, "name")
    if !name.has || !std.mem.eql(name.value, "zero") {
        return 22
    }
    let query_name: Maybe<Span<u8>> = std.http.requestQueryValue(request.value, "name")
    if !query_name.has || !std.mem.eql(query_name.value, "zero") {
        return 28
    }
    let limited_body: Maybe<Span<u8>> = std.http.requestBodyWithin(request.value, 16)
    let too_large_body: Maybe<Span<u8>> = std.http.requestBodyWithin(request.value, 4)
    if !limited_body.has || !std.mem.eql(limited_body.value, "{\"ping\":1}") || too_large_body.has {
        return 29
    }
    if !std.http.requestMatches(request.value, "POST", "/api") || std.http.requestMatches(request.value, "GET", "/api") {
        return 30
    }
    if !std.http.requestMethodIs(request.value, "POST") || std.http.requestMethodIs(request.value, "GET") {
        return 44
    }
    if !std.http.requestIsPost(request.value, "/api") || std.http.requestIsGet(request.value, "/api") {
        return 45
    }
    if !std.http.requestPathStartsWith(request.value, "/a") || std.http.requestPathStartsWith(request.value, "/users") {
        return 46
    }
    let path_tail: Maybe<Span<u8>> = std.http.requestPathTailAfter(request.value, "/")
    if !path_tail.has || !std.mem.eql(path_tail.value, "api") {
        return 47
    }
    let missing_tail: Maybe<Span<u8>> = std.http.requestPathTailAfter(request.value, "/users/")
    if missing_tail.has {
        return 48
    }
    let put_request: Span<u8> = "PUT /users/7\n\n"
    let patch_request: Span<u8> = "PATCH /users/7\n\n"
    let delete_request: Span<u8> = "DELETE /users/7\n\n"
    if !std.http.requestIsPut(put_request, "/users/7") || !std.http.requestIsPatch(patch_request, "/users/7") || !std.http.requestIsDelete(delete_request, "/users/7") {
        return 49
    }
    let user_id: Maybe<Span<u8>> = std.http.requestPathTailAfter(put_request, "/users/")
    if !user_id.has || !std.mem.eql(user_id.value, "7") {
        return 50
    }
    if !std.http.requestHasJsonContentType(request.value) {
        return 35
    }
    let json_body: Maybe<Span<u8>> = std.http.requestJsonBodyWithin(request.value, 16)
    let too_large_json_body: Maybe<Span<u8>> = std.http.requestJsonBodyWithin(request.value, 4)
    if !json_body.has || !std.mem.eql(json_body.value, "{\"ping\":1}") || too_large_json_body.has {
        return 36
    }
    let upper_json_request: Span<u8> = "POST /api\ncontent-type: Application/JSON; charset=utf-8\n\n{\"ok\":true}"
    if !std.http.requestHasJsonContentType(upper_json_request) {
        return 37
    }
    let invalid_json_request: Span<u8> = "POST /api\ncontent-type: application/json\n\nnot-json"
    let invalid_json_body: Maybe<Span<u8>> = std.http.requestJsonBodyWithin(invalid_json_request, 64)
    if invalid_json_body.has {
        return 38
    }
    let routed_request: Span<u8> = "POST /users/42/books\naccept: application/json, text/plain;q=0.5\ncontent-type: application/json; charset=utf-8\ncontent-length: 15\n\n{\"name\":\"zero\"}"
    if !std.http.requestRouteMatches(routed_request, "POST", "/users/:id/*") || std.http.requestRouteMatches(routed_request, "GET", "/users/:id/*") {
        return 60
    }
    let path_id: Maybe<Span<u8>> = std.http.requestPathParam(routed_request, "/users/:id/*", "id")
    let raw_path_id: Maybe<Span<u8>> = std.http.pathParam("/users/42/books", "/users/:id/*", "id")
    if !path_id.has || !raw_path_id.has || !std.mem.eql(path_id.value, "42") || !std.mem.eql(raw_path_id.value, "42") {
        return 61
    }
    if !std.http.pathMatchesPattern("/users/42/books", "/users/:id/*") || std.http.pathMatchesPattern("/users", "/users/:id") {
        return 62
    }
    if std.http.pathMatchesPattern("/admin/users/delete", "/admin/*/delete") {
        return 105
    }
    let content_length: Maybe<usize> = std.http.requestContentLength(routed_request)
    let routed_content_type: Maybe<Span<u8>> = std.http.requestContentType(routed_request)
    if !content_length.has || content_length.value != 15 || !routed_content_type.has || !std.mem.eql(routed_content_type.value, "application/json") {
        return 63
    }
    if !std.http.requestAcceptsJson(routed_request) || !std.http.requestAccepts(routed_request, "text/plain") || std.http.requestAccepts(routed_request, "application/xml") {
        return 64
    }
    let no_accept_request: Span<u8> = "GET /plain\n\n"
    if !std.http.requestAcceptsJson(no_accept_request) || !std.http.requestAccepts(no_accept_request, "text/plain") {
        return 102
    }
    let q_zero_accept_request: Span<u8> = "GET /plain\naccept: application/json;q=0, text/html\n\n"
    if std.http.requestAcceptsJson(q_zero_accept_request) || !std.http.requestAccepts(q_zero_accept_request, "text/html") {
        return 103
    }
    let wildcard_q_zero_request: Span<u8> = "GET /plain\naccept: */*;q=0, text/html;q=1\n\n"
    if std.http.requestAccepts(wildcard_q_zero_request, "application/json") || !std.http.requestAccepts(wildcard_q_zero_request, "text/html") {
        return 104
    }
    let exact_deny_after_wildcard_request: Span<u8> = "GET /plain\naccept: */*, application/json;q=0\n\n"
    if std.http.requestAcceptsJson(exact_deny_after_wildcard_request) || !std.http.requestAccepts(exact_deny_after_wildcard_request, "text/html") {
        return 106
    }
    let routed_name: Maybe<Span<u8>> = std.http.requestJsonField(routed_request, "name", 64)
    if !routed_name.has || !std.mem.eql(routed_name.value, "\"zero\"") {
        return 65
    }
    var get_buf: [64]u8 = [0_u8; 64]
    let get_request: Maybe<Span<u8>> = std.http.writeRequest(get_buf, "GET /health", "")
    if !get_request.has || !std.mem.eql(get_request.value, "GET /health\r\n\r\n") {
        return 23
    }
    var header_request_buf: [128]u8 = [0_u8; 128]
    let header_request: Maybe<Span<u8>> = std.http.writeRequestWithHeader(header_request_buf, "GET /api", "accept: application/json", "")
    if !header_request.has || !std.str.contains(header_request.value, "accept: application/json") {
        return 66
    }
    var bad_single_header_request_buf: [160]u8 = [0_u8; 160]
    let bad_single_header_request: Maybe<Span<u8>> = std.http.writeRequestWithHeader(bad_single_header_request_buf, "GET /api", "accept: application/json\n", "")
    if bad_single_header_request.has {
        return 107
    }
    if !std.http.headerBlockSafe("accept: application/json\nx-client: zero") || std.http.headerBlockSafe("bad\rname: value") {
        return 70
    }
    var method_request_buf: [128]u8 = [0_u8; 128]
    let method_request: Maybe<Span<u8>> = std.http.writeMethodRequest(method_request_buf, "PUT", "/users/7", "body")
    if !method_request.has || !std.str.contains(method_request.value, "PUT /users/7") || !std.str.contains(method_request.value, "content-length: 4") {
        return 71
    }
    var get_short_buf: [64]u8 = [0_u8; 64]
    let get_short: Maybe<Span<u8>> = std.http.writeGetRequest(get_short_buf, "/health")
    if !get_short.has || !std.mem.eql(get_short.value, "GET /health\r\n\r\n") {
        return 72
    }
    var head_short_buf: [64]u8 = [0_u8; 64]
    let head_short: Maybe<Span<u8>> = std.http.writeHeadRequest(head_short_buf, "/health")
    if !head_short.has || !std.mem.eql(head_short.value, "HEAD /health\r\n\r\n") {
        return 89
    }
    var delete_short_buf: [64]u8 = [0_u8; 64]
    let delete_short: Maybe<Span<u8>> = std.http.writeDeleteRequest(delete_short_buf, "/users/7")
    if !delete_short.has || !std.mem.eql(delete_short.value, "DELETE /users/7\r\n\r\n") {
        return 90
    }
    var long_target: [520]u8 = [97_u8; 520]
    long_target[0] = 47_u8
    var long_get_buf: [700]u8 = [0_u8; 700]
    let long_get: Maybe<Span<u8>> = std.http.writeGetRequest(long_get_buf, long_target)
    if !long_get.has || !std.http.requestIsGet(long_get.value, long_target) {
        return 96
    }
    var post_json_buf: [160]u8 = [0_u8; 160]
    let post_json: Maybe<Span<u8>> = std.http.writePostJsonRequest(post_json_buf, "/users", "{\"name\":\"zero\"}")
    if !post_json.has || !std.str.contains(post_json.value, "POST /users") || !std.str.contains(post_json.value, "content-type: application/json") {
        return 73
    }
    var json_method_buf: [160]u8 = [0_u8; 160]
    let json_method: Maybe<Span<u8>> = std.http.writeJsonMethodRequest(json_method_buf, "POST", "/bulk", "{\"ok\":true}")
    if !json_method.has || !std.str.contains(json_method.value, "POST /bulk") || !std.http.requestHasJsonContentType(json_method.value) {
        return 91
    }
    var put_json_buf: [160]u8 = [0_u8; 160]
    let put_json: Maybe<Span<u8>> = std.http.writePutJsonRequest(put_json_buf, "/users/7", "{\"name\":\"zero\"}")
    if !put_json.has || !std.http.requestIsPut(put_json.value, "/users/7") {
        return 92
    }
    var patch_json_buf: [160]u8 = [0_u8; 160]
    let patch_json: Maybe<Span<u8>> = std.http.writePatchJsonRequest(patch_json_buf, "/users/7", "{\"name\":\"zero\"}")
    if !patch_json.has || !std.http.requestIsPatch(patch_json.value, "/users/7") {
        return 93
    }
    var multi_header_request_buf: [192]u8 = [0_u8; 192]
    let multi_header_request: Maybe<Span<u8>> = std.http.writeRequestWithHeaders(multi_header_request_buf, "GET /api", "accept: application/json\nx-client: zero", "")
    if !multi_header_request.has || !std.str.contains(multi_header_request.value, "accept: application/json\r\nx-client: zero") {
        return 74
    }
    var json_header_request_buf: [192]u8 = [0_u8; 192]
    let json_header_request: Maybe<Span<u8>> = std.http.writeJsonRequestWithHeader(json_header_request_buf, "POST /api", "authorization: Bearer token", "{\"ok\":true}")
    if !json_header_request.has || !std.str.contains(json_header_request.value, "authorization: Bearer token") || !std.http.requestHasJsonContentType(json_header_request.value) {
        return 75
    }
    var json_headers_request_buf: [224]u8 = [0_u8; 224]
    let json_headers_request: Maybe<Span<u8>> = std.http.writeJsonRequestWithHeaders(json_headers_request_buf, "PATCH /api", "authorization: Bearer token\nx-client: zero", "{\"ok\":true}")
    if !json_headers_request.has || !std.str.contains(json_headers_request.value, "x-client: zero") || !std.http.requestIsPatch(json_headers_request.value, "/api") {
        return 76
    }
    var bad_request_header_buf: [160]u8 = [0_u8; 160]
    let bad_request_header: Maybe<Span<u8>> = std.http.writeRequestWithHeaders(bad_request_header_buf, "POST /api", "content-length: 999", "x")
    if bad_request_header.has {
        return 97
    }
    var bad_transfer_request_header_buf: [160]u8 = [0_u8; 160]
    let bad_transfer_request_header: Maybe<Span<u8>> = std.http.writeRequestWithHeader(bad_transfer_request_header_buf, "POST /api", "transfer-encoding: chunked", "x")
    if bad_transfer_request_header.has {
        return 109
    }
    var bad_json_request_header_buf: [160]u8 = [0_u8; 160]
    let bad_json_request_header: Maybe<Span<u8>> = std.http.writeJsonRequestWithHeader(bad_json_request_header_buf, "POST /api", "content-type: text/plain", "{}")
    if bad_json_request_header.has {
        return 98
    }
    var bad_json_transfer_request_header_buf: [192]u8 = [0_u8; 192]
    let bad_json_transfer_request_header: Maybe<Span<u8>> = std.http.writeJsonRequestWithHeaders(bad_json_transfer_request_header_buf, "POST /api", "transfer-encoding: chunked", "{}")
    if bad_json_transfer_request_header.has {
        return 110
    }
    if !std.http.methodAllowed("PATCH", "GET, PATCH") || !std.http.requestMethodAllowed("PATCH /users/7\n\n", "GET, PATCH") || !std.http.requestRouteMethodAllowed("PATCH /users/7\n\n", "/users/:id", "PATCH, DELETE") {
        return 77
    }
    var absolute_buf: [64]u8 = [0_u8; 64]
    let absolute_request: Maybe<Span<u8>> = std.http.writeRequest(absolute_buf, "GET https://example.com", "")
    if !absolute_request.has {
        return 31
    }
    let absolute_path: Maybe<Span<u8>> = std.http.requestPath(absolute_request.value)
    if !absolute_path.has || !std.mem.eql(absolute_path.value, "/") {
        return 33
    }
    var invalid_buf: [64]u8 = [0_u8; 64]
    let invalid_request: Maybe<Span<u8>> = std.http.writeRequest(invalid_buf, "GET", "")
    if invalid_request.has {
        return 34
    }
    var response_buf: [256]u8 = [0_u8; 256]
    let response: Maybe<Span<u8>> = std.http.writeJsonCreated(response_buf, "{\"ok\":true}")
    if !response.has {
        return 24
    }
    let header: HttpHeaderValue = std.http.headerValue(response.value, "content-type")
    let header_bytes: Maybe<Span<u8>> = std.http.headerBytes(response.value, header)
    if !header_bytes.has || !std.mem.eql(header_bytes.value, "application/json") {
        return 25
    }
    if std.http.responseBodyOffset(response.value) >= std.mem.len(response.value) {
        return 26
    }
    let response_body: Maybe<Span<u8>> = std.http.responseBodyBytes(response.value)
    if !response_body.has || !std.mem.eql(response_body.value, "{\"ok\":true}") {
        return 39
    }
    var custom_header_buf: [192]u8 = [0_u8; 192]
    let custom_header_response: Maybe<Span<u8>> = std.http.writeResponseWithHeader(custom_header_buf, 202_u16, "x-request-id: abc123", "accepted")
    if !custom_header_response.has || !std.str.contains(custom_header_response.value, "202 Accepted") || !std.str.contains(custom_header_response.value, "x-request-id: abc123") {
        return 67
    }
    var bad_single_header_response_buf: [160]u8 = [0_u8; 160]
    let bad_single_header_response: Maybe<Span<u8>> = std.http.writeResponseWithHeader(bad_single_header_response_buf, 200_u16, "x-request-id: abc123\r\n", "ok")
    if bad_single_header_response.has {
        return 108
    }
    var json_header_buf: [192]u8 = [0_u8; 192]
    let json_header_response: Maybe<Span<u8>> = std.http.writeJsonResponseWithHeader(json_header_buf, 200_u16, "cache-control: no-store", "{\"ok\":true}")
    if !json_header_response.has || !std.str.contains(json_header_response.value, "cache-control: no-store") || !std.str.contains(json_header_response.value, "content-type: application/json") {
        return 68
    }
    if !std.http.responseStatusIs(json_header_response.value, 200_u16) || std.http.responseStatusIs(json_header_response.value, 404_u16) {
        return 78
    }
    if std.http.responseStatusIs("HTTP/1.1 2000 nope\r\n\r\n", 200_u16) || std.http.responseStatusIs("HTTP/1.1 200OK\r\n\r\n", 200_u16) {
        return 111
    }
    let invalid_short_status: Maybe<u16> = std.http.responseStatus("HTTP/1.1 099 Weird\r\n\r\n")
    if invalid_short_status.has {
        return 112
    }
    let json_header_type: Maybe<Span<u8>> = std.http.responseContentType(json_header_response.value)
    let json_cache_header: Maybe<Span<u8>> = std.http.responseHeader(json_header_response.value, "cache-control")
    if !json_header_type.has || !std.mem.eql(json_header_type.value, "application/json") || !json_cache_header.has || !std.mem.eql(json_cache_header.value, "no-store") {
        return 79
    }
    if !std.http.responseMatches(json_header_response.value, 200_u16, "application/json", "{\"ok\":true}") || !std.http.responseBodyEquals(json_header_response.value, "{\"ok\":true}") {
        return 80
    }
    var multi_header_response_buf: [224]u8 = [0_u8; 224]
    let multi_header_response: Maybe<Span<u8>> = std.http.writeJsonResponseWithHeaders(multi_header_response_buf, 202_u16, "cache-control: no-store\nx-request-id: abc123", "{\"accepted\":true}")
    if !multi_header_response.has || !std.http.responseMatches(multi_header_response.value, 202_u16, "application/json", "{\"accepted\":true}") {
        return 81
    }
    let request_id: Maybe<Span<u8>> = std.http.responseHeader(multi_header_response.value, "x-request-id")
    if !request_id.has || !std.mem.eql(request_id.value, "abc123") {
        return 82
    }
    var plain_multi_header_buf: [192]u8 = [0_u8; 192]
    let plain_multi_header_response: Maybe<Span<u8>> = std.http.writeResponseWithHeaders(plain_multi_header_buf, 202_u16, "content-type: text/plain\nx-request-id: plain", "accepted")
    if !plain_multi_header_response.has || !std.http.responseMatches(plain_multi_header_response.value, 202_u16, "text/plain", "accepted") {
        return 94
    }
    var bad_response_header_buf: [160]u8 = [0_u8; 160]
    let bad_response_header: Maybe<Span<u8>> = std.http.writeResponseWithHeaders(bad_response_header_buf, 200_u16, "connection: keep-alive", "ok")
    if bad_response_header.has {
        return 99
    }
    var bad_transfer_response_header_buf: [160]u8 = [0_u8; 160]
    let bad_transfer_response_header: Maybe<Span<u8>> = std.http.writeResponseWithHeader(bad_transfer_response_header_buf, 200_u16, "transfer-encoding: chunked", "ok")
    if bad_transfer_response_header.has {
        return 113
    }
    var bad_json_response_header_buf: [160]u8 = [0_u8; 160]
    let bad_json_response_header: Maybe<Span<u8>> = std.http.writeJsonResponseWithHeader(bad_json_response_header_buf, 200_u16, "content-type: text/plain", "{}")
    if bad_json_response_header.has {
        return 100
    }
    var bad_json_transfer_response_header_buf: [192]u8 = [0_u8; 192]
    let bad_json_transfer_response_header: Maybe<Span<u8>> = std.http.writeJsonResponseWithHeaders(bad_json_transfer_response_header_buf, 200_u16, "transfer-encoding: chunked", "{}")
    if bad_json_transfer_response_header.has {
        return 114
    }
    if !std.mem.eql(std.http.contentTypeForPath("/assets/app.js"), "text/javascript; charset=utf-8") || !std.mem.eql(std.http.contentTypeForPath("/data.bin"), "application/octet-stream") {
        return 83
    }
    var static_response_buf: [192]u8 = [0_u8; 192]
    let static_response: Maybe<Span<u8>> = std.http.writeStaticResponse(static_response_buf, 200_u16, "/styles/app.css", "body{}")
    if !static_response.has || !std.http.responseMatches(static_response.value, 200_u16, "text/css", "body{}") {
        return 84
    }
    var cookie_buf: [192]u8 = [0_u8; 192]
    let cookie_response: Maybe<Span<u8>> = std.http.writeJsonResponseWithCookie(cookie_buf, 200_u16, "sid=abc123", "{\"ok\":true}")
    if !cookie_response.has || !std.str.contains(cookie_response.value, "set-cookie: sid=abc123") {
        return 69
    }
    var long_cookie: [300]u8 = [97_u8; 300]
    var long_cookie_buf: [512]u8 = [0_u8; 512]
    let long_cookie_response: Maybe<Span<u8>> = std.http.writeJsonResponseWithCookie(long_cookie_buf, 200_u16, long_cookie, "{\"ok\":true}")
    var long_cookie_header: Maybe<Span<u8>> = null
    if long_cookie_response.has {
        long_cookie_header = std.http.responseHeader(long_cookie_response.value, "set-cookie")
    }
    if !long_cookie_response.has || !long_cookie_header.has || !std.mem.eql(long_cookie_header.value, long_cookie[..]) {
        return 101
    }
    var ok_buf: [128]u8 = [0_u8; 128]
    let ok_response: Maybe<Span<u8>> = std.http.writeJsonOk(ok_buf, "{\"ok\":true}")
    if !ok_response.has || !std.str.contains(ok_response.value, "200 OK") {
        return 40
    }
    var bad_buf: [128]u8 = [0_u8; 128]
    let bad_response: Maybe<Span<u8>> = std.http.writeJsonBadRequest(bad_buf, "{\"error\":\"bad\"}")
    if !bad_response.has || !std.str.contains(bad_response.value, "400 Bad Request") {
        return 41
    }
    var unauthorized_buf: [128]u8 = [0_u8; 128]
    let unauthorized_response: Maybe<Span<u8>> = std.http.writeJsonUnauthorized(unauthorized_buf, "{\"error\":\"unauthorized\"}")
    if !unauthorized_response.has || !std.str.contains(unauthorized_response.value, "401 Unauthorized") {
        return 51
    }
    var forbidden_buf: [128]u8 = [0_u8; 128]
    let forbidden_response: Maybe<Span<u8>> = std.http.writeJsonForbidden(forbidden_buf, "{\"error\":\"forbidden\"}")
    if !forbidden_response.has || !std.str.contains(forbidden_response.value, "403 Forbidden") {
        return 52
    }
    var not_found_buf: [128]u8 = [0_u8; 128]
    let not_found_response: Maybe<Span<u8>> = std.http.writeJsonNotFound(not_found_buf, "{\"error\":\"not_found\"}")
    if !not_found_response.has || !std.str.contains(not_found_response.value, "404 Not Found") {
        return 42
    }
    var method_buf: [160]u8 = [0_u8; 160]
    let method_response: Maybe<Span<u8>> = std.http.writeJsonMethodNotAllowed(method_buf, "{\"error\":\"method_not_allowed\"}")
    if !method_response.has || !std.str.contains(method_response.value, "405 Method Not Allowed") {
        return 43
    }
    var conflict_buf: [128]u8 = [0_u8; 128]
    let conflict_response: Maybe<Span<u8>> = std.http.writeJsonConflict(conflict_buf, "{\"error\":\"conflict\"}")
    if !conflict_response.has || !std.str.contains(conflict_response.value, "409 Conflict") {
        return 53
    }
    var unprocessable_buf: [160]u8 = [0_u8; 160]
    let unprocessable_response: Maybe<Span<u8>> = std.http.writeJsonUnprocessable(unprocessable_buf, "{\"error\":\"unprocessable\"}")
    if !unprocessable_response.has || !std.str.contains(unprocessable_response.value, "422 Unprocessable Content") {
        return 54
    }
    var limited_buf: [160]u8 = [0_u8; 160]
    let limited_response: Maybe<Span<u8>> = std.http.writeJsonTooManyRequests(limited_buf, "{\"error\":\"rate_limited\"}")
    if !limited_response.has || !std.str.contains(limited_response.value, "429 Too Many Requests") {
        return 55
    }
    var internal_buf: [160]u8 = [0_u8; 160]
    let internal_response: Maybe<Span<u8>> = std.http.writeJsonInternalServerError(internal_buf, "{\"error\":\"internal\"}")
    if !internal_response.has || !std.str.contains(internal_response.value, "500 Internal Server Error") {
        return 56
    }
    var error_buf: [160]u8 = [0_u8; 160]
    let error_response: Maybe<Span<u8>> = std.http.writeJsonError(error_buf, 422_u16, "bad_request")
    if !error_response.has || !std.str.contains(error_response.value, "422 Unprocessable Content") {
        return 57
    }
    let error_body: Maybe<Span<u8>> = std.http.responseBodyBytes(error_response.value)
    if !error_body.has || !std.mem.eql(error_body.value, "{\"error\":\"bad_request\"}") {
        return 58
    }
    var unsafe_error_buf: [160]u8 = [0_u8; 160]
    let unsafe_error_response: Maybe<Span<u8>> = std.http.writeJsonError(unsafe_error_buf, 400_u16, "Bad Request")
    if unsafe_error_response.has {
        return 59
    }
    var redirect_buf: [128]u8 = [0_u8; 128]
    let redirect_response: Maybe<Span<u8>> = std.http.writeFound(redirect_buf, "/next")
    if !redirect_response.has {
        return 85
    }
    let redirect_location: Maybe<Span<u8>> = std.http.responseRedirectLocation(redirect_response.value)
    if !redirect_location.has || !std.mem.eql(redirect_location.value, "/next") {
        return 86
    }
    var test_request_buf: [160]u8 = [0_u8; 160]
    let test_request: Maybe<Span<u8>> = std.http.testJsonRequest(test_request_buf, "POST", "/tests", "{\"ok\":true}")
    if !test_request.has || !std.http.requestIsPost(test_request.value, "/tests") || !std.http.requestHasJsonContentType(test_request.value) {
        return 87
    }
    let test_body: Maybe<Span<u8>> = std.http.requestJsonBodyWithin(test_request.value, 64)
    if !test_body.has || !std.mem.eql(test_body.value, "{\"ok\":true}") {
        return 88
    }
    var plain_test_request_buf: [96]u8 = [0_u8; 96]
    let plain_test_request: Maybe<Span<u8>> = std.http.testRequest(plain_test_request_buf, "HEAD", "/tests", "")
    if !plain_test_request.has || !std.http.requestIsHead(plain_test_request.value, "/tests") {
        return 95
    }
    var plain_response_buf: [128]u8 = [0_u8; 128]
    let plain_response: Maybe<Span<u8>> = std.http.writeNoContent(plain_response_buf)
    if !plain_response.has || !std.str.contains(plain_response.value, "204 No Content") {
        return 27
    }
    return 32
}