HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-json/test-json.c
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);
}