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 2001–2196 of 2,196

 
TEST(json_dispatch_in_addr_data) {
        _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_data addr;
                struct in_addr_data null_addr;
        } data = {};
 
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr",      _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr_data, offsetof(typeof(data), addr)      },
                                        { "null_addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr_data, offsetof(typeof(data), null_addr) },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(be32toh(data.addr.address.in.s_addr), 0xC0A80101U);
        ASSERT_EQ(data.null_addr.address.in.s_addr, 0U);
        ASSERT_EQ(data.addr.family, AF_INET);
        ASSERT_EQ(data.null_addr.family, AF_UNSPEC);
 
        struct in_addr_data 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_data, 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_data, 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_data, 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_data, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
        ASSERT_EQ(be32toh(data.addr.address.in.s_addr), 0xC0A80101U);
        ASSERT_EQ(data.addr.family, AF_INET);
 
        /* 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_data, 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_data, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &dummy), EINVAL);
 
        /* ::1 */
        j = sd_json_variant_unref(j);
        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))));
 
        zero(data);
        ASSERT_OK(sd_json_dispatch(j,
                                (const sd_json_dispatch_field[]) {
                                        { "addr",      _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr_data, offsetof(typeof(data), addr)      },
                                        { "null_addr", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr_data, offsetof(typeof(data), null_addr) },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(data.addr.address.in6.s6_addr[15], 1);
        for (size_t i = 0; i < 15; i++)
                ASSERT_EQ(data.addr.address.in6.s6_addr[i], 0);
        for (size_t i = 0; i < 16; i++)
                ASSERT_EQ(data.null_addr.address.in6.s6_addr[i], 0);
        ASSERT_EQ(data.addr.family, AF_INET6);
        ASSERT_EQ(data.null_addr.family, AF_UNSPEC);
 
        /* 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_in_addr_data, 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_in_addr_data, 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_in_addr_data, 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_in_addr_data, 0 },
                                        {},
                                },
                                /* flags= */ 0,
                                &data));
 
        ASSERT_EQ(data.addr.address.in6.s6_addr[15], 1);
        for (size_t i = 0; i < 15; i++)
                ASSERT_EQ(data.addr.address.in6.s6_addr[i], 0);
        ASSERT_EQ(data.addr.family, AF_INET6);
}
 
DEFINE_TEST_MAIN(LOG_DEBUG);