HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-json/test-json.c

113,777 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 6992d095c666f004843c0ec17a1407bf2e1ac7a7

Lines 1001–2000 of 2,196

                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_UNSIGNED(UINT32_MAX)),
                                             SD_JSON_BUILD_PAIR("f", SD_JSON_BUILD_STRING("4294967295")),
                                             SD_JSON_BUILD_PAIR("g", SD_JSON_BUILD_INTEGER(INT32_MIN)),
                                             SD_JSON_BUILD_PAIR("h", SD_JSON_BUILD_STRING("-2147483648")),
                                             SD_JSON_BUILD_PAIR("i", SD_JSON_BUILD_UNSIGNED(UINT16_MAX)),
                                             SD_JSON_BUILD_PAIR("j", SD_JSON_BUILD_STRING("65535")),
                                             SD_JSON_BUILD_PAIR("k", SD_JSON_BUILD_INTEGER(INT16_MIN)),
                                             SD_JSON_BUILD_PAIR("l", SD_JSON_BUILD_STRING("-32768")),
                                             SD_JSON_BUILD_PAIR("m", SD_JSON_BUILD_INTEGER(UINT8_MAX)),
                                             SD_JSON_BUILD_PAIR("n", SD_JSON_BUILD_STRING("255")),
                                             SD_JSON_BUILD_PAIR("o", SD_JSON_BUILD_INTEGER(INT8_MIN)),
                                             SD_JSON_BUILD_PAIR("p", SD_JSON_BUILD_STRING("-128")))) >= 0);
 
        assert_se(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, stdout, /* prefix= */ NULL) >= 0);
 
        sd_json_dispatch_field table[] = {
                { "a", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct foobar, a) },
                { "b", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct foobar, b) },
                { "c", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int64,  offsetof(struct foobar, c) },
                { "d", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int64,  offsetof(struct foobar, d) },
                { "e", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(struct foobar, e) },
                { "f", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(struct foobar, f) },
                { "g", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int32,  offsetof(struct foobar, g) },
                { "h", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int32,  offsetof(struct foobar, h) },
                { "i", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct foobar, i) },
                { "j", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct foobar, j) },
                { "k", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int16,  offsetof(struct foobar, k) },
                { "l", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int16,  offsetof(struct foobar, l) },
                { "m", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8,  offsetof(struct foobar, m) },
                { "n", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8,  offsetof(struct foobar, n) },
                { "o", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int8,   offsetof(struct foobar, o) },
                { "p", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int8,   offsetof(struct foobar, p) },
                {}
        };
 
        assert_se(sd_json_dispatch(v, table, SD_JSON_LOG, &foobar) >= 0);
 
        assert_se(foobar.a == UINT64_MAX);
        assert_se(foobar.b == UINT64_MAX);
        assert_se(foobar.c == INT64_MIN);
        assert_se(foobar.d == INT64_MIN);
 
        assert_se(foobar.e == UINT32_MAX);
        assert_se(foobar.f == UINT32_MAX);
        assert_se(foobar.g == INT32_MIN);
        assert_se(foobar.h == INT32_MIN);
 
        assert_se(foobar.i == UINT16_MAX);
        assert_se(foobar.j == UINT16_MAX);
        assert_se(foobar.k == INT16_MIN);
        assert_se(foobar.l == INT16_MIN);
 
        assert_se(foobar.m == UINT8_MAX);
        assert_se(foobar.n == UINT8_MAX);
        assert_se(foobar.o == INT8_MIN);
        assert_se(foobar.p == INT8_MIN);
}
 
typedef enum mytestenum {
        myfoo, mybar, mybaz, with_some_dashes, _mymax, _myinvalid = -EINVAL,
} mytestenum;
 
static const char *mytestenum_table[_mymax] = {
        [myfoo] = "myfoo",
        [mybar] = "mybar",
        [mybaz] = "mybaz",
        [with_some_dashes] = "with-some-dashes",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP(mytestenum, mytestenum);
 
static JSON_DISPATCH_ENUM_DEFINE(dispatch_mytestenum, mytestenum, mytestenum_from_string);
 
TEST(json_dispatch_enum_define) {
 
        struct data {
                mytestenum a, b, c, d, e;
        } data = {
                .a = _myinvalid,
                .b = _myinvalid,
                .c = _myinvalid,
                .d = mybar,
                .e = _myinvalid,
        };
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
        assert_se(sd_json_buildo(&j,
                                 SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_STRING("mybaz")),
                                 SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("mybar")),
                                 SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_STRING("myfoo")),
                                 SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_NULL),
                                 SD_JSON_BUILD_PAIR("e", JSON_BUILD_STRING_UNDERSCORIFY(mytestenum_to_string(with_some_dashes)))) >= 0);
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "a", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, a), 0 },
                                        { "b", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, b), 0 },
                                        { "c", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, c), 0 },
                                        { "d", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, d), 0 },
                                        { "e", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, e), 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data) >= 0);
 
        assert(data.a == mybaz);
        assert(data.b == mybar);
        assert(data.c == myfoo);
        assert(data.d < 0);
        assert(data.e == with_some_dashes);
}
 
TEST(json_dispatch_double) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
        assert_se(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("x1", SD_JSON_BUILD_REAL(0.5)),
                                             SD_JSON_BUILD_PAIR("x2", SD_JSON_BUILD_REAL(-0.5)),
                                             SD_JSON_BUILD_PAIR("x3", JSON_BUILD_CONST_STRING("infinity")),
                                             SD_JSON_BUILD_PAIR("x4", JSON_BUILD_CONST_STRING("-infinity")),
                                             SD_JSON_BUILD_PAIR("x5", JSON_BUILD_CONST_STRING("nan")),
                                             SD_JSON_BUILD_PAIR("x6", JSON_BUILD_CONST_STRING("inf")),
                                             SD_JSON_BUILD_PAIR("x7", JSON_BUILD_CONST_STRING("-inf")))) >= 0);
 
        struct data {
                double x1, x2, x3, x4, x5, x6, x7;
        } data = {};
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "x1", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x1), 0 },
                                        { "x2", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x2), 0 },
                                        { "x3", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x3), 0 },
                                        { "x4", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x4), 0 },
                                        { "x5", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x5), 0 },
                                        { "x6", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x6), 0 },
                                        { "x7", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_double, offsetof(struct data, x7), 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data) >= 0);
 
        assert_se(ABS(data.x1 - 0.5) < 0.01);
        assert_se(ABS(data.x2 + 0.5) < 0.01);
        assert_se(isinf(data.x3));
        assert_se(data.x3 > 0);
        assert_se(isinf(data.x4));
        assert_se(data.x4 < 0);
        assert_se(isnan(data.x5));
        assert_se(isinf(data.x6));
        assert_se(data.x6 > 0);
        assert_se(isinf(data.x7));
        assert_se(data.x7 < 0);
}
 
TEST(json_sensitive) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL, *b = NULL, *v = NULL;
        _cleanup_free_ char *s = NULL;
        int r;
 
        assert_se(sd_json_build(&a, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "bar", "baz", "foo", "qux", "baz"))) >= 0);
        assert_se(sd_json_build(&b, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "qux"))) >= 0);
 
        sd_json_variant_sensitive(a);
 
        assert_se(sd_json_variant_format(a, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
        ASSERT_STREQ(s, "\"<sensitive data>\"");
        s = mfree(s);
 
        r = sd_json_variant_format(b, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
        assert_se(r >= 0);
        assert_se(s);
        assert_se((size_t) r == strlen(s));
        s = mfree(s);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        r = sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
        assert_se(r >= 0);
        assert_se(s);
        assert_se((size_t) r == strlen(s));
        s = mfree(s);
        v = sd_json_variant_unref(v);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR_VARIANT("b", b),
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        r = sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
        assert_se(r >= 0);
        assert_se(s);
        assert_se((size_t) r == strlen(s));
        s = mfree(s);
        v = sd_json_variant_unref(v);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR_VARIANT("b", b),
                                             SD_JSON_BUILD_PAIR_VARIANT("a", a),
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
        ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"<sensitive data>\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}");
        s = mfree(s);
        v = sd_json_variant_unref(v);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR_VARIANT("b", b),
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR_VARIANT("a", a),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
        ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"<sensitive data>\",\"d\":\"-9223372036854775808\",\"e\":{}}");
        s = mfree(s);
        v = sd_json_variant_unref(v);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR_VARIANT("b", b),
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR_VARIANT("a", a),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
        ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"<sensitive data>\",\"e\":{}}");
        s = mfree(s);
        v = sd_json_variant_unref(v);
 
        assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR_VARIANT("b", b),
                                             SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
                                             SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
                                             SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT),
                                             SD_JSON_BUILD_PAIR_VARIANT("a", a))) >= 0);
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
        ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"<sensitive data>\"}");
}
 
TEST(json_iovec) {
        struct iovec iov1 = CONST_IOVEC_MAKE_STRING("üxknürz"), iov2 = CONST_IOVEC_MAKE_STRING("wuffwuffmiau");
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
        assert_se(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("nr1", JSON_BUILD_IOVEC_BASE64(&iov1)),
                                             SD_JSON_BUILD_PAIR("nr2", JSON_BUILD_IOVEC_HEX(&iov2)))) >= 0);
 
        sd_json_variant_dump(j, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, /* f= */ NULL, /* prefix= */ NULL);
 
        _cleanup_(iovec_done) struct iovec a = {}, b = {};
        assert_se(json_variant_unbase64_iovec(sd_json_variant_by_key(j, "nr1"), &a) >= 0);
        assert_se(json_variant_unhex_iovec(sd_json_variant_by_key(j, "nr2"), &b) >= 0);
 
        assert_se(iovec_equal(&iov1, &a));
        assert_se(iovec_equal(&iov2, &b));
        assert_se(iovec_memcmp(&iov2, &a) < 0);
        assert_se(iovec_memcmp(&iov1, &b) > 0);
}
 
TEST(json_dispatch_nullable) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
        assert_se(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("x1", JSON_BUILD_CONST_STRING("foo")),
                                             SD_JSON_BUILD_PAIR("x2", JSON_BUILD_CONST_STRING("bar")),
                                             SD_JSON_BUILD_PAIR("x3", JSON_BUILD_CONST_STRING("waldo")),
                                             SD_JSON_BUILD_PAIR("x4", JSON_BUILD_CONST_STRING("foo2")),
                                             SD_JSON_BUILD_PAIR("x5", JSON_BUILD_CONST_STRING("bar2")),
                                             SD_JSON_BUILD_PAIR("x6", JSON_BUILD_CONST_STRING("waldo2")),
                                             SD_JSON_BUILD_PAIR("x7", SD_JSON_BUILD_NULL),
                                             SD_JSON_BUILD_PAIR("x8", SD_JSON_BUILD_NULL),
                                             SD_JSON_BUILD_PAIR("x9", SD_JSON_BUILD_NULL))) >= 0);
 
        struct data {
                const char *x1, *x2, *x3, *x4, *x5, *x6, *x7, *x8, *x9;
        } data = {
                .x1 = POINTER_MAX,
                .x2 = POINTER_MAX,
                .x3 = POINTER_MAX,
                .x4 = POINTER_MAX,
                .x5 = POINTER_MAX,
                .x6 = POINTER_MAX,
                .x7 = POINTER_MAX,
                .x8 = POINTER_MAX,
                .x9 = POINTER_MAX,
        };
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "x1", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x1), SD_JSON_NULLABLE    },
                                        { "x2", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x2), SD_JSON_REFUSE_NULL },
                                        { "x3", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x3), 0                   },
                                        { "x4", SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(struct data, x4), SD_JSON_NULLABLE    },
                                        { "x5", SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(struct data, x5), SD_JSON_REFUSE_NULL },
                                        { "x6", SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(struct data, x6), 0                   },
                                        { "x7", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x7), SD_JSON_NULLABLE    },
                                        { "x8", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x8), 0                   },
                                        { "x9", SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(struct data, x9), SD_JSON_NULLABLE    },
                                        {},
                                },
                                /* flags= */ 0,
                                &data) >= 0);
 
        assert_se(streq_ptr(data.x1, "foo"));
        assert_se(streq_ptr(data.x2, "bar"));
        assert_se(streq_ptr(data.x3, "waldo"));
        assert_se(streq_ptr(data.x4, "foo2"));
        assert_se(streq_ptr(data.x5, "bar2"));
        assert_se(streq_ptr(data.x6, "waldo2"));
        assert_se(!data.x7);
        assert_se(!data.x8);
        assert_se(!data.x9);
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "x7", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_const_string, offsetof(struct data, x7), SD_JSON_REFUSE_NULL },
                                        {},
                                },
                                /* flags= */ SD_JSON_ALLOW_EXTENSIONS,
                                &data) == -EINVAL);
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "x7", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct data, x7), SD_JSON_REFUSE_NULL },
                                        {},
                                },
                                /* flags= */ SD_JSON_ALLOW_EXTENSIONS,
                                &data) == -EINVAL);
 
        assert_se(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "x7", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct data, x7), 0 },
                                        {},
                                },
                                /* flags= */ SD_JSON_ALLOW_EXTENSIONS,
                                &data) == -EINVAL);
}
 
TEST(parse_continue) {
        unsigned line = 23, column = 43;
 
        /* First try to parse with continue logic off, this should fail */
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *x = NULL;
        assert_se(sd_json_parse_with_source("4711 512", "piff", /* flags= */ 0, &x, &line, &column) == -EINVAL);
        assert_se(line == 1);
        assert_se(column == 6);
 
        /* Then try to parse with continue logic on, which should yield two numbers */
        const char *p = "4711 512";
        assert_se(sd_json_parse_with_source_continue(&p, "piff", /* flags= */ 0, &x, &line, &column) >= 0);
        assert_se(sd_json_variant_is_unsigned(x));
        assert_se(sd_json_variant_unsigned(x) == 4711);
        x = sd_json_variant_unref(x);
 
        assert_se(streq_ptr(p, " 512"));
        assert_se(sd_json_parse_with_source_continue(&p, "piff", /* flags= */ 0, &x, &line, &column) >= 0);
        assert_se(sd_json_variant_is_unsigned(x));
        assert_se(sd_json_variant_unsigned(x) == 512);
 
        assert_se(isempty(p));
        assert_se(sd_json_parse_with_source_continue(&p, "piff", /* flags= */ 0, &x, &line, &column) == -EINVAL);
}
 
TEST(pidref) {
        _cleanup_(pidref_done) PidRef myself = PIDREF_NULL, pid1 = PIDREF_NULL;
 
        assert_se(pidref_set_pid(&myself, 0) >= 0);
        assert_se(pidref_set_pid(&pid1, 1) >= 0);
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        sd_id128_t randomized_boot_id;
        assert_se(sd_id128_randomize(&randomized_boot_id) >= 0);
        assert_se(sd_json_buildo(&v,
                                 JSON_BUILD_PAIR_PIDREF("myself", &myself),
                                 JSON_BUILD_PAIR_PIDREF("pid1", &pid1),
                                 SD_JSON_BUILD_PAIR("remote", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_UNSIGNED("pid", 1),
                                                                                   SD_JSON_BUILD_PAIR_UNSIGNED("pidfdId", 4711),
                                                                                   SD_JSON_BUILD_PAIR_ID128("bootId", randomized_boot_id))),
                                 SD_JSON_BUILD_PAIR("automatic", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_UNSIGNED("pid", 0)))) >= 0);
 
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        struct {
                PidRef myself, pid1, remote, automatic;
        } data = {
                .myself = PIDREF_NULL,
                .pid1 = PIDREF_NULL,
                .remote = PIDREF_NULL,
                .automatic = PIDREF_NULL,
        };
 
        assert_se(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "myself",    _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_pidref, voffsetof(data, myself),    SD_JSON_STRICT },
                                          { "pid1",      _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_pidref, voffsetof(data, pid1),      SD_JSON_STRICT },
                                          { "remote",    _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_pidref, voffsetof(data, remote),    0              },
                                          { "automatic", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_pidref, voffsetof(data, automatic), SD_JSON_RELAX  },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data) >= 0);
 
        assert_se(pidref_equal(&myself, &data.myself));
        assert_se(pidref_equal(&pid1, &data.pid1));
 
        assert_se(!pidref_equal(&myself, &data.pid1));
        assert_se(!pidref_equal(&pid1, &data.myself));
        assert_se(!pidref_equal(&myself, &data.remote));
        assert_se(!pidref_equal(&pid1, &data.remote));
 
        assert_se((myself.fd_id > 0) == (data.myself.fd_id > 0));
        assert_se((pid1.fd_id > 0) == (data.pid1.fd_id > 0));
 
        assert_se(!pidref_is_set(&data.automatic));
        assert_se(pidref_is_automatic(&data.automatic));
        assert_se(pidref_is_set(&data.remote));
        assert_se(pidref_is_remote(&data.remote));
 
        pidref_done(&data.myself);
        pidref_done(&data.pid1);
        pidref_done(&data.remote);
}
 
TEST(devnum) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        dev_t dev = makedev(123, 456), parsed;
 
        ASSERT_OK(json_variant_new_devnum(&v, dev));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        ASSERT_OK(json_dispatch_devnum("devnum", v, /* flags= */ 0, &parsed));
        ASSERT_EQ(major(parsed), major(dev));
        ASSERT_EQ(minor(parsed), minor(dev));
        v = sd_json_variant_unref(v);
 
        dev = makedev(1 << 12, 456);
        ASSERT_OK(json_variant_new_devnum(&v, dev));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        ASSERT_FAIL(json_dispatch_devnum("devnum", v, /* flags= */ 0, &parsed));
        v = sd_json_variant_unref(v);
 
        dev = makedev(123, 1 << 20);
        ASSERT_OK(json_variant_new_devnum(&v, dev));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        ASSERT_FAIL(json_dispatch_devnum("devnum", v, /* flags= */ 0, &parsed));
}
 
TEST(fd_info) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
        _cleanup_close_ int fd = -EBADF;
 
        /* directories */
        ASSERT_OK(json_variant_new_fd_info(&v, AT_FDCWD));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        v = sd_json_variant_unref(v);
 
        ASSERT_OK_ERRNO(fd = openat(AT_FDCWD, ".", O_CLOEXEC | O_DIRECTORY | O_PATH));
        ASSERT_OK(json_variant_new_fd_info(&v, fd));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        v = sd_json_variant_unref(v);
        fd = safe_close(fd);
 
        /* regular file */
        ASSERT_OK(fd = open_tmpfile_unlinkable(NULL, O_RDWR));
        ASSERT_OK(json_variant_new_fd_info(&v, fd));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        v = sd_json_variant_unref(v);
        fd = safe_close(fd);
 
        fd = open("/sys/class/net/lo/uevent", O_CLOEXEC | O_PATH);
        if (fd >= 0) {
                ASSERT_OK(json_variant_new_fd_info(&v, fd));
                ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
                v = sd_json_variant_unref(v);
                fd = safe_close(fd);
        }
 
        /* block device */
        fd = open("/dev/sda", O_CLOEXEC | O_PATH);
        if (fd >= 0) {
                ASSERT_OK(json_variant_new_fd_info(&v, fd));
                ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
                v = sd_json_variant_unref(v);
                fd = safe_close(fd);
        }
 
        /* stream */
        ASSERT_OK(json_variant_new_fd_info(&v, fileno(stdout)));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        v = sd_json_variant_unref(v);
 
        /* socket */
        ASSERT_OK_ERRNO(fd = socket(AF_INET, SOCK_DGRAM, 0));
        ASSERT_OK(json_variant_new_fd_info(&v, fd));
        ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
        v = sd_json_variant_unref(v);
        fd = safe_close(fd);
 
        /* pidfd */
        ASSERT_OK(pidref_set_pid(&pidref, 0));
        if (pidref.fd >= 0) {
                ASSERT_OK(json_variant_new_fd_info(&v, pidref.fd));
                ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
                v = sd_json_variant_unref(v);
        }
        pidref_done(&pidref);
 
        ASSERT_OK(pidref_set_pid(&pidref, 1));
        if (pidref.fd >= 0) {
                ASSERT_OK(json_variant_new_fd_info(&v, pidref.fd));
                ASSERT_OK(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO | SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL));
                v = sd_json_variant_unref(v);
        }
        pidref_done(&pidref);
}
 
TEST(unit_name) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        ASSERT_OK(sd_json_buildo(&v,
                                 SD_JSON_BUILD_PAIR_STRING("plain", "myservice.service"),
                                 SD_JSON_BUILD_PAIR_STRING("instance", "myservice@instance1.service"),
                                 SD_JSON_BUILD_PAIR_STRING("template", "myservice@.service")));
 
        sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
 
        struct {
                const char *plain, *instance, *template;
        } data = {};
 
        ASSERT_OK(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "plain",    SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, plain),    SD_JSON_STRICT },
                                          { "instance", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, instance), 0              },
                                          { "template", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, template), SD_JSON_RELAX  },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data));
 
        ASSERT_STREQ(data.plain, "myservice.service");
        ASSERT_STREQ(data.instance, "myservice@instance1.service");
        ASSERT_STREQ(data.template, "myservice@.service");
 
        ASSERT_ERROR(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "plain",    SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, plain),    SD_JSON_RELAX  },
                                          /* instance value is not allowed with SD_JSON_STRICT */
                                          { "instance", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, instance), SD_JSON_STRICT },
                                          { "template", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, template), SD_JSON_RELAX  },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data), EINVAL);
 
        ASSERT_ERROR(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "plain",    SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, plain),    SD_JSON_RELAX  },
                                          { "instance", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, instance), SD_JSON_RELAX  },
                                          /* template value is not allowed by default */
                                          { "template", SD_JSON_VARIANT_STRING, json_dispatch_const_unit_name, voffsetof(data, template), 0 },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data), EINVAL);
}
 
TEST(access_mode) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        ASSERT_OK(sd_json_parse("{"
                                " \"a\" : \"0755\", "
                                " \"b\" : 448, "
                                " \"c\" : null, "
                                " \"d\" : \"01755\" "
                                "}",
                                /* flags= */ 0,
                                &v,
                                /* reterr_line= */ NULL,
                                /* reterr_column= */ NULL));
 
        struct {
                mode_t a, b, c, d;
        } mm = { 1, 2, 3, 4 };
 
        ASSERT_OK(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "a", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_access_mode, voffsetof(mm, a), 0 },
                                          { "b", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_access_mode, voffsetof(mm, b), 0 },
                                          { "c", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_access_mode, voffsetof(mm, c), 0 },
                                          { "d", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_access_mode, voffsetof(mm, d), 0 },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &mm));
 
        ASSERT_EQ(mm.a, (mode_t) 0755);
        ASSERT_EQ(mm.b, (mode_t) 0700);
        ASSERT_EQ(mm.c, MODE_INVALID);
        ASSERT_EQ(mm.d, (mode_t) 01755);
 
        /* retry with SD_JSON_STRICT, where 'd' should not parse anymore */
        ASSERT_ERROR(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "d", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_access_mode, voffsetof(mm, d), SD_JSON_STRICT },
                                          {},
                                  },
                                  /* flags= */ SD_JSON_ALLOW_EXTENSIONS,
                                  &mm), ERANGE);
}
 
TEST(job_id) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
 
        ASSERT_OK(sd_json_parse("{\"a\": 1, \"b\": 4294967295, \"c\": null}",
                                /* flags= */ 0,
                                &v,
                                /* reterr_line= */ NULL,
                                /* reterr_column= */ NULL));
 
        struct {
                uint32_t a, b, c;
        } data = { 99, 99, 99 };
 
        ASSERT_OK(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "a", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_job_id, voffsetof(data, a), 0 },
                                          { "b", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_job_id, voffsetof(data, b), 0 },
                                          { "c", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_job_id, voffsetof(data, c), 0 },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data));
 
        ASSERT_EQ(data.a, UINT32_C(1));
        ASSERT_EQ(data.b, UINT32_MAX);
        ASSERT_EQ(data.c, UINT32_C(0));
 
        /* Zero is not a valid job ID */
        sd_json_variant_unrefp(&v);
        ASSERT_OK(sd_json_parse("{\"a\": 0}",
                                /* flags= */ 0,
                                &v,
                                /* reterr_line= */ NULL,
                                /* reterr_column= */ NULL));
 
        ASSERT_ERROR(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "a", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_job_id, voffsetof(data, a), 0 },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data), EINVAL);
 
        /* Negative values are not valid */
        sd_json_variant_unrefp(&v);
        ASSERT_OK(sd_json_parse("{\"a\": -1}",
                                /* flags= */ 0,
                                &v,
                                /* reterr_line= */ NULL,
                                /* reterr_column= */ NULL));
 
        ASSERT_ERROR(sd_json_dispatch(
                                  v,
                                  (const sd_json_dispatch_field[]) {
                                          { "a", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_job_id, voffsetof(data, a), 0 },
                                          {},
                                  },
                                  /* flags= */ 0,
                                  &data), EINVAL);
}
 
static void test_json_variant_compare_one(const char *a, const char *b, int expected) {
        int r;
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *aa = NULL;
        if (!isempty(a))
                ASSERT_OK(sd_json_parse(a, /* flags= */ 0, &aa, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *bb = NULL;
        if (!isempty(b))
                ASSERT_OK(sd_json_parse(b, /* flags= */ 0, &bb, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
 
        r = json_variant_compare(aa, bb);
 
        log_debug("%s vs %s → %i (expected %i)", a, b, r, expected);
 
        if (expected < 0)
                ASSERT_LT(r, 0);
        else if (expected > 0)
                ASSERT_GT(r, 0);
        else
                ASSERT_EQ(r, 0);
 
        r = json_variant_compare(bb, aa);
 
        if (expected < 0)
                ASSERT_GT(r, 0);
        else if (expected > 0)
                ASSERT_LT(r, 0);
        else
                ASSERT_EQ(r, 0);
}
 
TEST(json_variant_compare) {
        test_json_variant_compare_one("null", "\"a\"", -1);
        test_json_variant_compare_one(NULL, "\"a\"", -1);
        test_json_variant_compare_one("0", "1", -1);
        test_json_variant_compare_one("1", "0", 1);
        test_json_variant_compare_one("0", "0", 0);
        test_json_variant_compare_one("1", "1", 0);
        test_json_variant_compare_one("1", "null", 1);
        test_json_variant_compare_one("null", "1", -1);
        test_json_variant_compare_one("null", "null", 0);
        test_json_variant_compare_one("false", "true", -1);
        test_json_variant_compare_one("true", "false", 1);
        test_json_variant_compare_one("true", "true", 0);
        test_json_variant_compare_one("false", "false", 0);
        test_json_variant_compare_one("\"a\"", "\"b\"", -1);
        test_json_variant_compare_one("\"b\"", "\"a\"", 1);
        test_json_variant_compare_one("18446744073709551615", "0", 1);
        test_json_variant_compare_one("0", "18446744073709551615", -1);
        test_json_variant_compare_one("18446744073709551615", "18446744073709551615", 0);
        test_json_variant_compare_one("-9223372036854775808", "18446744073709551615", -1);
        test_json_variant_compare_one("18446744073709551615", "-9223372036854775808", 1);
        test_json_variant_compare_one("1.1", "3.4", -1);
        test_json_variant_compare_one("1", "3.4", -1);
        test_json_variant_compare_one("[1,2]", "[1,2]", 0);
        test_json_variant_compare_one("[1,2]", "[2,1]", -1);
        test_json_variant_compare_one("[1,2]", "[1,2,3]", -1);
        test_json_variant_compare_one("{}", "{\"a\":\"b\"}", -1);
        test_json_variant_compare_one("{\"a\":\"b\"}", "{\"a\":\"b\"}", 0);
        test_json_variant_compare_one("{\"a\":\"b\"}", "{\"b\":\"c\"}", 1);
        test_json_variant_compare_one("{\"a\":\"b\",\"b\":\"c\"}", "{\"b\":\"c\",\"a\":\"b\"}", 0);
        test_json_variant_compare_one("{\"a\":\"b\",\"b\":\"c\"}", "{\"a\":\"b\"}", 1);
}
 
TEST(must_be) {
        ASSERT_OK(sd_json_parse("null", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("null", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("null", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("null", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("true", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("true", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("true", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("true", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("\"foo\"", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("\"foo\"", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("\"foo\"", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("\"foo\"", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("4711", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("4711", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("4711", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("4711", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("-4711", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("-4711", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("-4711", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("-4711", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("-4.5", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("-4.5", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("-4.5", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_ERROR(sd_json_parse("-4.5", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
 
        ASSERT_OK(sd_json_parse("{}", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_OK(sd_json_parse("{}", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("{}", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_OK(sd_json_parse("{}", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
 
        ASSERT_OK(sd_json_parse("[]", /* flags= */ 0, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_ERROR(sd_json_parse("[]", SD_JSON_PARSE_MUST_BE_OBJECT, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL), EINVAL);
        ASSERT_OK(sd_json_parse("[]", SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
        ASSERT_OK(sd_json_parse("[]", SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_MUST_BE_ARRAY, /* ret= */ NULL, /* reterr_line= */ NULL, /* reterr_column= */ NULL));
}
 
TEST(json_dispatch_in_addr) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
        /* 192.168.1.1 = { 192, 168, 1, 1 } */
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", JSON_BUILD_IN4_ADDR(&(const struct in_addr) { .s_addr = htobe32(0xC0A80101U) })),
                                             SD_JSON_BUILD_PAIR("null_addr", SD_JSON_BUILD_NULL))));
 
        struct {
                struct in_addr addr;
                struct in_addr null_addr;
        } data = {};
 
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr",      _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, offsetof(typeof(data), addr)      },
                                        { "null_addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, offsetof(typeof(data), null_addr) },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(be32toh(data.addr.s_addr), 0xC0A80101U);
        ASSERT_EQ(data.null_addr.s_addr, 0U);
 
        struct in_addr dummy = {};
 
        /* Too few bytes (3 instead of 4) */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(192), SD_JSON_BUILD_UNSIGNED(168), SD_JSON_BUILD_UNSIGNED(1))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* Too many bytes (5 instead of 4) */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(192), SD_JSON_BUILD_UNSIGNED(168), SD_JSON_BUILD_UNSIGNED(1), SD_JSON_BUILD_UNSIGNED(1), SD_JSON_BUILD_UNSIGNED(0))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* Not an array or string */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                                SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_BOOLEAN(true)))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* A string */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", JSON_BUILD_CONST_STRING("192.168.1.1")))));
        zero(data);
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
        ASSERT_EQ(be32toh(data.addr.s_addr), 0xC0A80101U);
 
        /* Byte value out of range (> 255) */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(256), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(1))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* Negative element */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_INTEGER(-1), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(1))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
}
 
TEST(json_dispatch_in6_addr) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
        /* ::1 */
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", JSON_BUILD_IN6_ADDR(&(const struct in6_addr) { .s6_addr = { [15] = 1 } })),
                                             SD_JSON_BUILD_PAIR("null_addr", SD_JSON_BUILD_NULL))));
 
        struct {
                struct in6_addr addr;
                struct in6_addr null_addr;
        } data = {};
 
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr",      _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, offsetof(typeof(data), addr)      },
                                        { "null_addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, offsetof(typeof(data), null_addr) },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(data.addr.s6_addr[15], 1);
        for (size_t i = 0; i < 15; i++)
                ASSERT_EQ(data.addr.s6_addr[i], 0);
        for (size_t i = 0; i < 16; i++)
                ASSERT_EQ(data.null_addr.s6_addr[i], 0);
 
        struct in6_addr dummy = {};
 
        /* Too few bytes (15 instead of 16) */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(1))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* Too many bytes (17 instead of 16) */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_ARRAY(
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0),
                                                                                SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(0), SD_JSON_BUILD_UNSIGNED(1),
                                                                                SD_JSON_BUILD_UNSIGNED(0))))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* Not an array */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", SD_JSON_BUILD_BOOLEAN(true)))));
        ASSERT_ERROR(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* A string */
        j = sd_json_variant_unref(j);
        ASSERT_OK(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
                                             SD_JSON_BUILD_PAIR("addr", JSON_BUILD_CONST_STRING("::1")))));
 
        zero(data);
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(data.addr.s6_addr[15], 1);
        for (size_t i = 0; i < 15; i++)
                ASSERT_EQ(data.addr.s6_addr[i], 0);
}