test/json_test.c - master - niceSOFT/openssl

test/json_test.c
693 строки17 KB
Norbert Pocs
Fix macro staircase formatting issue
10 июн 2026, 16:24
10 июн 2026, 16:24dfe2585
/*
 * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

#include "testutil.h"
#include "internal/json_enc.h"

struct helper {
    OSSL_JSON_ENC j;
    int init;
    uint32_t flags;
    BIO *mem_bio;
};

static int helper_ensure(struct helper *h)
{
    if (h->init)
        return 1;

    if (!TEST_ptr(h->mem_bio = BIO_new(BIO_s_mem())))
        return 0;

    if (!ossl_json_init(&h->j, h->mem_bio, h->flags)) {
        BIO_free_all(h->mem_bio);
        h->mem_bio = NULL;
        return 0;
    }

    h->init = 1;
    return 1;
}

static void helper_cleanup(struct helper *h)
{
    BIO_free_all(h->mem_bio);
    h->mem_bio = NULL;

    if (h->init) {
        ossl_json_cleanup(&h->j);
        h->init = 0;
    }
}

static void helper_set_flags(struct helper *h, uint32_t flags)
{
    helper_cleanup(h);
    h->flags = flags;
}

struct script_word {
    void *p;
    uint64_t u64;
    int64_t i64;
    double d;
    void (*fp)(void);
};

#define OP_P(x) { (x) }
#define OP_U64(x) { NULL, (x) }
#define OP_I64(x) { NULL, 0, (x) }
#define OP_D(x) { NULL, 0, 0, (x) }
#define OP_FP(x) { NULL, 0, 0, 0, (void (*)(void))(x) }

struct script_info {
    const char *name, *title;
    const struct script_word *words;
    size_t num_words;
    const char *expected_output;
    size_t expected_output_len;
};

typedef const struct script_info *(*info_func)(void);

enum {
    OPK_END,
    OPK_CALL, /* (OSSL_JSON_ENC *) */
    OPK_CALL_P, /* (OSSL_JSON_ENC *, const void *) */
    OPK_CALL_I, /* (OSSL_JSON_ENC *, int) */
    OPK_CALL_U64, /* (OSSL_JSON_ENC *, uint64_t) */
    OPK_CALL_I64, /* (OSSL_JSON_ENC *, int64_t) */
    OPK_CALL_D, /* (OSSL_JSON_ENC *, double) */
    OPK_CALL_PZ, /* (OSSL_JSON_ENC *, const void *, size_t) */
    OPK_ASSERT_ERROR, /* (OSSL_JSON_ENC *, int expect_error) */
    OPK_INIT_FLAGS /* (uint32_t flags) */
};

typedef void (*fp_type)(OSSL_JSON_ENC *);
typedef void (*fp_p_type)(OSSL_JSON_ENC *, const void *);
typedef void (*fp_i_type)(OSSL_JSON_ENC *, int);
typedef void (*fp_u64_type)(OSSL_JSON_ENC *, uint64_t);
typedef void (*fp_i64_type)(OSSL_JSON_ENC *, int64_t);
typedef void (*fp_d_type)(OSSL_JSON_ENC *, double);
typedef void (*fp_pz_type)(OSSL_JSON_ENC *, const void *, size_t);

#define OP_END() OP_U64(OPK_END)
#define OP_CALL(f) OP_U64(OPK_CALL), OP_FP(f)
#define OP_CALL_P(f, x) OP_U64(OPK_CALL_P), OP_FP(f), OP_P(x)
#define OP_CALL_I(f, x) OP_U64(OPK_CALL_I), OP_FP(f), OP_I64(x)
#define OP_CALL_U64(f, x) OP_U64(OPK_CALL_U64), OP_FP(f), OP_U64(x)
#define OP_CALL_I64(f, x) OP_U64(OPK_CALL_I64), OP_FP(f), OP_I64(x)
#define OP_CALL_D(f, x) OP_U64(OPK_CALL_D), OP_FP(f), OP_D(x)
#define OP_CALL_PZ(f, x, xl) OP_U64(OPK_CALL_PZ), OP_FP(f), OP_P(x), OP_U64(xl)
#define OP_ASSERT_ERROR(err) OP_U64(OPK_ASSERT_ERROR), OP_U64(err),
#define OP_INIT_FLAGS(flags) OP_U64(OPK_INIT_FLAGS), OP_U64(flags)

#define OPJ_BEGIN_O() OP_CALL(ossl_json_object_begin),
#define OPJ_END_O() OP_CALL(ossl_json_object_end),
#define OPJ_BEGIN_A() OP_CALL(ossl_json_array_begin),
#define OPJ_END_A() OP_CALL(ossl_json_array_end),
#define OPJ_NULL() OP_CALL(ossl_json_null),
#define OPJ_BOOL(x) OP_CALL_I(ossl_json_bool, (x)),
#define OPJ_U64(x) OP_CALL_U64(ossl_json_u64, (x)),
#define OPJ_I64(x) OP_CALL_I64(ossl_json_i64, (x)),
#define OPJ_KEY(x) OP_CALL_P(ossl_json_key, (x)),
#define OPJ_STR(x) OP_CALL_P(ossl_json_str, (x)),
#define OPJ_STR_LEN(x, xl) OP_CALL_PZ(ossl_json_str_len, (x), (xl)),
#define OPJ_STR_HEX(x, xl) OP_CALL_PZ(ossl_json_str_hex, (x), (xl)),

#define BEGIN_SCRIPT(name, title, flags)                     \
    static const struct script_info *get_script_##name(void) \
    {                                                        \
        static const char script_name[] = #name;             \
        static const char script_title[] = #title;           \
                                                             \
        static const struct script_word script_words[] = {   \
            OP_INIT_FLAGS(flags),

#define END_SCRIPT_EXPECTING(s, slen)                                      \
    OP_END(),                                                              \
    }                                                                      \
    ;                                                                      \
    static const struct script_info script_info = {                        \
        script_name, script_title, script_words, OSSL_NELEM(script_words), \
        (s), (slen)                                                        \
    };                                                                     \
    return &script_info;                                                   \
    }

#ifdef OPENSSL_SYS_VMS
/*
 * The VMS C compiler recognises \u in strings, and emits a warning, which
 * stops the build.  Because we think we know what we're doing, we change that
 * particular message to be merely informational.
 */
#pragma message informational UCNNOMAP
#endif

#define END_SCRIPT_EXPECTING_S(s) END_SCRIPT_EXPECTING(s, SIZE_MAX)
#define END_SCRIPT_EXPECTING_Q(s) END_SCRIPT_EXPECTING(#s, sizeof(#s) - 1)

#define SCRIPT(name) get_script_##name

BEGIN_SCRIPT(null, "serialize a single null", 0)
OPJ_NULL()
END_SCRIPT_EXPECTING_Q(null)

BEGIN_SCRIPT(obj_empty, "serialize an empty object", 0)
OPJ_BEGIN_O()
OPJ_END_O()
END_SCRIPT_EXPECTING_Q({})

BEGIN_SCRIPT(array_empty, "serialize an empty array", 0)
OPJ_BEGIN_A()
OPJ_END_A()
END_SCRIPT_EXPECTING_Q([])

BEGIN_SCRIPT(bool_false, "serialize false", 0)
OPJ_BOOL(false)
END_SCRIPT_EXPECTING_Q(false)

BEGIN_SCRIPT(bool_true, "serialize true", 0)
OPJ_BOOL(true)
END_SCRIPT_EXPECTING_Q(true)

BEGIN_SCRIPT(u64_0, "serialize u64(0)", 0)
OPJ_U64(0)
END_SCRIPT_EXPECTING_Q(0)

BEGIN_SCRIPT(u64_1, "serialize u64(1)", 0)
OPJ_U64(1)
END_SCRIPT_EXPECTING_Q(1)

BEGIN_SCRIPT(u64_10, "serialize u64(10)", 0)
OPJ_U64(10)
END_SCRIPT_EXPECTING_Q(10)

BEGIN_SCRIPT(u64_12345, "serialize u64(12345)", 0)
OPJ_U64(12345)
END_SCRIPT_EXPECTING_Q(12345)

BEGIN_SCRIPT(u64_18446744073709551615, "serialize u64(18446744073709551615)", 0)
OPJ_U64(18446744073709551615ULL)
END_SCRIPT_EXPECTING_Q(18446744073709551615)

BEGIN_SCRIPT(i64_0, "serialize i64(0)", 0)
OPJ_I64(0)
END_SCRIPT_EXPECTING_Q(0)

BEGIN_SCRIPT(i64_1, "serialize i64(1)", 0)
OPJ_I64(1)
END_SCRIPT_EXPECTING_Q(1)

BEGIN_SCRIPT(i64_2, "serialize i64(2)", 0)
OPJ_I64(2)
END_SCRIPT_EXPECTING_Q(2)

BEGIN_SCRIPT(i64_10, "serialize i64(10)", 0)
OPJ_I64(10)
END_SCRIPT_EXPECTING_Q(10)

BEGIN_SCRIPT(i64_12345, "serialize i64(12345)", 0)
OPJ_I64(12345)
END_SCRIPT_EXPECTING_Q(12345)

BEGIN_SCRIPT(i64_9223372036854775807, "serialize i64(9223372036854775807)", 0)
OPJ_I64(9223372036854775807LL)
END_SCRIPT_EXPECTING_Q(9223372036854775807)

BEGIN_SCRIPT(i64_m1, "serialize i64(-1)", 0)
OPJ_I64(-1)
END_SCRIPT_EXPECTING_Q(-1)

BEGIN_SCRIPT(i64_m2, "serialize i64(-2)", 0)
OPJ_I64(-2)
END_SCRIPT_EXPECTING_Q(-2)

BEGIN_SCRIPT(i64_m10, "serialize i64(-10)", 0)
OPJ_I64(-10)
END_SCRIPT_EXPECTING_Q(-10)

BEGIN_SCRIPT(i64_m12345, "serialize i64(-12345)", 0)
OPJ_I64(-12345)
END_SCRIPT_EXPECTING_Q(-12345)

BEGIN_SCRIPT(i64_m9223372036854775807, "serialize i64(-9223372036854775807)", 0)
OPJ_I64(-9223372036854775807LL)
END_SCRIPT_EXPECTING_Q(-9223372036854775807)

BEGIN_SCRIPT(i64_m9223372036854775808, "serialize i64(-9223372036854775808)", 0)
OPJ_I64(-9223372036854775807LL - 1LL)
END_SCRIPT_EXPECTING_Q(-9223372036854775808)

BEGIN_SCRIPT(str_empty, "serialize \"\"", 0)
OPJ_STR("")
END_SCRIPT_EXPECTING_Q("")

BEGIN_SCRIPT(str_a, "serialize \"a\"", 0)
OPJ_STR("a")
END_SCRIPT_EXPECTING_Q("a")

BEGIN_SCRIPT(str_abc, "serialize \"abc\"", 0)
OPJ_STR("abc")
END_SCRIPT_EXPECTING_Q("abc")

BEGIN_SCRIPT(str_quote, "serialize with quote", 0)
OPJ_STR("abc\"def")
END_SCRIPT_EXPECTING_Q("abc\"def")

BEGIN_SCRIPT(str_quote2, "serialize with quote", 0)
OPJ_STR("abc\"\"def")
END_SCRIPT_EXPECTING_Q("abc\"\"def")

BEGIN_SCRIPT(str_escape, "serialize with various escapes", 0)
OPJ_STR("abc\"\"de'f\r\n\t\b\f\\\x01\v\x7f\\")
END_SCRIPT_EXPECTING_Q("abc\"\"de'f\r\n\t\b\f\\\u0001\u000b\u007f\\")

BEGIN_SCRIPT(str_len, "length-signalled string", 0)
OPJ_STR_LEN("abcdef", 6)
END_SCRIPT_EXPECTING_Q("abcdef")

BEGIN_SCRIPT(str_len0, "0-length-signalled string", 0)
OPJ_STR_LEN("", 0)
END_SCRIPT_EXPECTING_Q("")

BEGIN_SCRIPT(str_len_nul, "string with NUL", 0)
OPJ_STR_LEN("x\0y", 3)
END_SCRIPT_EXPECTING_Q("x\u0000y")

BEGIN_SCRIPT(hex_data0, "zero-length hex data", 0)
OPJ_STR_HEX("", 0)
END_SCRIPT_EXPECTING_Q("")

BEGIN_SCRIPT(hex_data, "hex data", 0)
OPJ_STR_HEX("\x00\x01\x5a\xfb\xff", 5)
END_SCRIPT_EXPECTING_Q("00015afbff")

BEGIN_SCRIPT(array_nest1, "serialize nested empty arrays", 0)
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_END_A()
END_SCRIPT_EXPECTING_Q([[]])

BEGIN_SCRIPT(array_nest2, "serialize nested empty arrays", 0)
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
END_SCRIPT_EXPECTING_Q([[[]]])

BEGIN_SCRIPT(array_nest3, "serialize nested empty arrays", 0)
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_END_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_END_A()
END_SCRIPT_EXPECTING_S("[[[],[],[]],[]]")

BEGIN_SCRIPT(array_nest4, "deep nested arrays", 0)
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_END_A()
OPJ_NULL()
OPJ_END_A()
END_SCRIPT_EXPECTING_S("[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]],null]")

BEGIN_SCRIPT(obj_nontrivial1, "serialize nontrivial object", 0)
OPJ_BEGIN_O()
OPJ_KEY("")
OPJ_NULL()
OPJ_END_O()
END_SCRIPT_EXPECTING_S("{\"\":null}")

BEGIN_SCRIPT(obj_nontrivial2, "serialize nontrivial object", 0)
OPJ_BEGIN_O()
OPJ_KEY("")
OPJ_NULL()
OPJ_KEY("x")
OPJ_NULL()
OPJ_END_O()
END_SCRIPT_EXPECTING_S("{\"\":null,\"x\":null}")

BEGIN_SCRIPT(obj_nest1, "serialize nested objects", 0)
OPJ_BEGIN_O()
OPJ_KEY("")
OPJ_BEGIN_O()
OPJ_KEY("x")
OPJ_U64(42)
OPJ_END_O()
OPJ_KEY("x")
OPJ_BEGIN_A()
OPJ_U64(42)
OPJ_U64(101)
OPJ_END_A()
OPJ_KEY("y")
OPJ_NULL()
OPJ_KEY("z")
OPJ_BEGIN_O()
OPJ_KEY("z0")
OPJ_I64(-1)
OPJ_KEY("z1")
OPJ_I64(-2)
OPJ_END_O()
OPJ_END_O()
END_SCRIPT_EXPECTING_S("{\"\":{\"x\":42},\"x\":[42,101],\"y\":null,\"z\":{\"z0\":-1,\"z1\":-2}}")

BEGIN_SCRIPT(err_obj_no_key, "error test: object item without key", 0)
OPJ_BEGIN_O()
OP_ASSERT_ERROR(0)
OPJ_NULL()
OP_ASSERT_ERROR(1)
OPJ_END_O()
OP_ASSERT_ERROR(1)
END_SCRIPT_EXPECTING_S("{")

BEGIN_SCRIPT(err_obj_multi_key, "error test: object item with repeated key", 0)
OPJ_BEGIN_O()
OPJ_KEY("x")
OP_ASSERT_ERROR(0)
OPJ_KEY("y")
OP_ASSERT_ERROR(1)
OPJ_NULL()
OP_ASSERT_ERROR(1)
END_SCRIPT_EXPECTING_S("{\"x\":")

BEGIN_SCRIPT(err_obj_no_value, "error test: object item with no value", 0)
OPJ_BEGIN_O()
OPJ_KEY("x")
OP_ASSERT_ERROR(0)
OPJ_END_O()
OP_ASSERT_ERROR(1)
END_SCRIPT_EXPECTING_S("{\"x\":")

BEGIN_SCRIPT(err_utf8, "error test: only basic ASCII supported", 0)
OPJ_STR("\x80")
OP_ASSERT_ERROR(0)
END_SCRIPT_EXPECTING_S("\"\\u0080\"")

BEGIN_SCRIPT(utf8_2, "test: valid UTF-8 2byte supported", 0)
OPJ_STR("low=\xc2\x80, high=\xdf\xbf")
OP_ASSERT_ERROR(0)
END_SCRIPT_EXPECTING_S("\"low=\xc2\x80, high=\xdf\xbf\"")

BEGIN_SCRIPT(utf8_3, "test: valid UTF-8 3byte supported", 0)
OPJ_STR("low=\xe0\xa0\x80, high=\xef\xbf\xbf")
OP_ASSERT_ERROR(0)
END_SCRIPT_EXPECTING_S("\"low=\xe0\xa0\x80, high=\xef\xbf\xbf\"")

BEGIN_SCRIPT(utf8_4, "test: valid UTF-8 4byte supported", 0)
OPJ_STR("low=\xf0\x90\xbf\xbf, high=\xf4\x8f\xbf\xbf")
OP_ASSERT_ERROR(0)
END_SCRIPT_EXPECTING_S("\"low=\xf0\x90\xbf\xbf, high=\xf4\x8f\xbf\xbf\"")

BEGIN_SCRIPT(ijson_int, "I-JSON: large integer", OSSL_JSON_FLAG_IJSON)
OPJ_BEGIN_A()
OPJ_U64(1)
OPJ_I64(-1)
OPJ_U64(9007199254740991)
OPJ_U64(9007199254740992)
OPJ_I64(-9007199254740991)
OPJ_I64(-9007199254740992)
OPJ_END_A()
END_SCRIPT_EXPECTING_S("[1,-1,9007199254740991,\"9007199254740992\",-9007199254740991,\"-9007199254740992\"]")

BEGIN_SCRIPT(multi_item, "multiple top level items", 0)
OPJ_NULL()
OPJ_NULL()
OPJ_BEGIN_A()
OPJ_END_A()
OPJ_BEGIN_A()
OPJ_END_A()
END_SCRIPT_EXPECTING_S("nullnull[][]")

BEGIN_SCRIPT(seq, "JSON-SEQ", OSSL_JSON_FLAG_SEQ)
OPJ_NULL()
OPJ_NULL()
OPJ_NULL()
OPJ_BEGIN_O()
OPJ_KEY("x")
OPJ_U64(1)
OPJ_KEY("y")
OPJ_BEGIN_O()
OPJ_END_O()
OPJ_END_O()
END_SCRIPT_EXPECTING_S("\x1Enull\n"
                       "\x1Enull\n"
                       "\x1Enull\n"
                       "\x1E{\"x\":1,\"y\":{}}\n")

static const info_func scripts[] = {
    SCRIPT(null),
    SCRIPT(obj_empty),
    SCRIPT(array_empty),
    SCRIPT(bool_false),
    SCRIPT(bool_true),
    SCRIPT(u64_0),
    SCRIPT(u64_1),
    SCRIPT(u64_10),
    SCRIPT(u64_12345),
    SCRIPT(u64_18446744073709551615),
    SCRIPT(i64_0),
    SCRIPT(i64_1),
    SCRIPT(i64_2),
    SCRIPT(i64_10),
    SCRIPT(i64_12345),
    SCRIPT(i64_9223372036854775807),
    SCRIPT(i64_m1),
    SCRIPT(i64_m2),
    SCRIPT(i64_m10),
    SCRIPT(i64_m12345),
    SCRIPT(i64_m9223372036854775807),
    SCRIPT(i64_m9223372036854775808),
    SCRIPT(str_empty),
    SCRIPT(str_a),
    SCRIPT(str_abc),
    SCRIPT(str_quote),
    SCRIPT(str_quote2),
    SCRIPT(str_escape),
    SCRIPT(str_len),
    SCRIPT(str_len0),
    SCRIPT(str_len_nul),
    SCRIPT(hex_data0),
    SCRIPT(hex_data),
    SCRIPT(array_nest1),
    SCRIPT(array_nest2),
    SCRIPT(array_nest3),
    SCRIPT(array_nest4),
    SCRIPT(obj_nontrivial1),
    SCRIPT(obj_nontrivial2),
    SCRIPT(obj_nest1),
    SCRIPT(err_obj_no_key),
    SCRIPT(err_obj_multi_key),
    SCRIPT(err_obj_no_value),
    SCRIPT(err_utf8),
    SCRIPT(utf8_2),
    SCRIPT(utf8_3),
    SCRIPT(utf8_4),
    SCRIPT(ijson_int),
    SCRIPT(multi_item),
    SCRIPT(seq),
};

/* Test runner. */
static int run_script(const struct script_info *info)
{
    int ok = 0, asserted = -1;
    const struct script_word *words = info->words;
    size_t wp = 0;
    struct script_word w;
    struct helper h = { 0 };
    BUF_MEM *bufp = NULL;

    TEST_info("running script '%s' (%s)", info->name, info->title);

#define GET_WORD() (w = words[wp++])
#define GET_U64() (GET_WORD().u64)
#define GET_I64() (GET_WORD().i64)
#define GET_FP() (GET_WORD().fp)
#define GET_P() (GET_WORD().p)

    for (;;)
        switch (GET_U64()) {
        case OPK_END:
            goto stop;
        case OPK_INIT_FLAGS:
            helper_set_flags(&h, (uint32_t)GET_U64());
            break;
        case OPK_CALL: {
            fp_type f = (fp_type)GET_FP();

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            f(&h.j);
            break;
        }
        case OPK_CALL_I: {
            fp_i_type f = (fp_i_type)GET_FP();

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            f(&h.j, (int)GET_I64());
            break;
        }
        case OPK_CALL_U64: {
            fp_u64_type f = (fp_u64_type)GET_FP();

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            f(&h.j, GET_U64());
            break;
        }
        case OPK_CALL_I64: {
            fp_i64_type f = (fp_i64_type)GET_FP();

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            f(&h.j, GET_I64());
            break;
        }
        case OPK_CALL_P: {
            fp_p_type f = (fp_p_type)GET_FP();

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            f(&h.j, GET_P());
            break;
        }
        case OPK_CALL_PZ: {
            fp_pz_type f = (fp_pz_type)GET_FP();
            void *p;
            uint64_t u64;

            if (!TEST_true(helper_ensure(&h)))
                goto err;

            p = GET_P();
            u64 = GET_U64();
            f(&h.j, p, (size_t)u64);
            break;
        }
        case OPK_ASSERT_ERROR: {
            if (!TEST_true(helper_ensure(&h)))
                goto err;

            asserted = (int)GET_U64();
            if (!TEST_int_eq(ossl_json_in_error(&h.j), asserted))
                goto err;

            break;
        }
#define OP_ASSERT_ERROR(err) OP_U64(OPK_ASSERT_ERROR), OP_U64(err),

        default:
            TEST_error("unknown opcode");
            goto err;
        }
stop:

    if (!TEST_true(helper_ensure(&h)))
        goto err;

    if (!TEST_true(ossl_json_flush(&h.j)))
        goto err;

    /* Implicit error check if not done explicitly. */
    if (asserted < 0 && !TEST_false(ossl_json_in_error(&h.j)))
        goto err;

    if (!TEST_true(BIO_get_mem_ptr(h.mem_bio, &bufp)))
        goto err;

    if (!TEST_mem_eq(bufp->data, bufp->length,
            info->expected_output,
            info->expected_output_len == SIZE_MAX
                ? strlen(info->expected_output)
                : info->expected_output_len))
        goto err;

    ok = 1;
err:
    if (!ok)
        TEST_error("script '%s' failed", info->name);

    helper_cleanup(&h);
    return ok;
}

static int test_json_enc(void)
{
    int ok = 1;
    size_t i;

    for (i = 0; i < OSSL_NELEM(scripts); ++i)
        if (!TEST_true(run_script(scripts[i]())))
            ok = 0;

    return ok;
}

int setup_tests(void)
{
    ADD_TEST(test_json_enc);
    return 1;
}