コード例 #1
0
ファイル: test-writer.c プロジェクト: OpenDZ/cvariant
static void test_writer_compound(void) {
        const char *type = "(uaum(s)u)";
        unsigned int u1, u2, u3, u4, u5, u6;
        const char *s1;
        CVariant *cv;
        int r;

        /* allocate variant and write each entry sequentially */

        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        r = c_variant_begin(cv, "(");
        assert(r >= 0);

        r = c_variant_write(cv, "u", 0xffff);
        assert(r >= 0);

        r = c_variant_write(cv, "au", 4, 1, 2, 3, 4);
        assert(r >= 0);

        r = c_variant_write(cv, "m(s)", true, "foo");
        assert(r >= 0);

        r = c_variant_write(cv, "u", 0xffffffffU);
        assert(r >= 0);

        r = c_variant_end(cv, ")");
        assert(r >= 0);

        /* seal and verify */
        r = c_variant_seal(cv);
        assert(r >= 0);

        r = c_variant_read(cv, "(uaum(s)u)",
                           &u1,
                           4, &u2, &u3, &u4, &u5,
                           true, &s1,
                           &u6);
        assert(r >= 0);
        assert(u1 == 0xffff);
        assert(u2 == 1);
        assert(u3 == 2);
        assert(u4 == 3);
        assert(u5 == 4);
        assert(!strcmp(s1, "foo"));
        assert(u6 == 0xffffffffU);

        cv = c_variant_free(cv);
        assert(!cv);
}
コード例 #2
0
ファイル: test-writer.c プロジェクト: OpenDZ/cvariant
static void test_writer_basic(void) {
        const char *type;
        unsigned int u1;
        CVariant *cv;
        int r;

        /* simple 'u' type */
        type = "u";
        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        u1 = 0xf0f0;
        r = c_variant_write(cv, "u", u1);
        assert(r >= 0);

        r = c_variant_seal(cv);
        assert(r >= 0);

        u1 = 0;
        r = c_variant_read(cv, "u", &u1);
        assert(r >= 0);
        assert(u1 == 0xf0f0);

        cv = c_variant_free(cv);

        /* compound '(u)' type */
        type = "(u)";
        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        u1 = 0xf0f0;
        r = c_variant_write(cv, "(u)", u1);
        assert(r >= 0);

        r = c_variant_seal(cv);
        assert(r >= 0);

        u1 = 0;
        r = c_variant_read(cv, "(u)", &u1);
        assert(r >= 0);
        assert(u1 == 0xf0f0);

        cv = c_variant_free(cv);

        /* array 'au' type */
        type = "au";
        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        u1 = 0xf0f0;
        r = c_variant_write(cv, "au", 1, u1);
        assert(r >= 0);

        r = c_variant_seal(cv);
        assert(r >= 0);

        u1 = 0;
        r = c_variant_read(cv, "au", 1, &u1);
        assert(r >= 0);
        assert(u1 == 0xf0f0);

        cv = c_variant_free(cv);

        /* maybe 'mu' type */
        type = "mu";
        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        u1 = 0xf0f0;
        r = c_variant_write(cv, "mu", true, u1);
        assert(r >= 0);

        r = c_variant_seal(cv);
        assert(r >= 0);

        u1 = 0;
        r = c_variant_read(cv, "mu", true, &u1);
        assert(r >= 0);
        assert(u1 == 0xf0f0);

        cv = c_variant_free(cv);

        /* variant 'v', 'u' */
        type = "v";
        r = c_variant_new(&cv, type, strlen(type));
        assert(r >= 0);

        u1 = 0xf0f0;
        r = c_variant_write(cv, "v", "u", u1);
        assert(r >= 0);

        r = c_variant_seal(cv);
        assert(r >= 0);

        u1 = 0;
        r = c_variant_read(cv, "v", "u", &u1);
        assert(r >= 0);
        assert(u1 == 0xf0f0);

        cv = c_variant_free(cv);
}
コード例 #3
0
ファイル: test-glib.c プロジェクト: larsu/c-variant
static void test_print_cv(CVariant *cv) {
        CVariantVarg varg;
        const char *type, *s;
        uint64_t u64;
        uint32_t u32;
        uint16_t u16;
        uint8_t u8;
        double f64;
        int r, c, nest;
        size_t n;

        nest = 0;
        type = c_variant_peek_type(cv, &n);

        for (c = c_variant_varg_init(&varg, type, n);
             c;
             c = c_variant_varg_next(&varg)) {
                switch (c) {
                case -1:
                        c_variant_exit(cv, NULL);

                        assert(nest-- > 0);
                        printf("%*s}\n", nest * 4, "");
                        break;
                case C_VARIANT_VARIANT:
                        c_variant_enter(cv, "v");
                        type = c_variant_peek_type(cv, &n);
                        c_variant_varg_push(&varg, type, n, -1);

                        printf("%*sv - \"%.*s\" {\n", nest * 4, "", (int)n,  type);
                        ++nest;
                        break;
                case C_VARIANT_MAYBE:
                        c_variant_enter(cv, "m");
                        n = c_variant_peek_count(cv);
                        c_variant_varg_enter_bound(&varg, cv, n);

                        printf("%*sMAYBE - %s {\n", nest * 4, "", n ? "SOMETHING" : "NOTHING");
                        ++nest;
                        break;
                case C_VARIANT_ARRAY:
                        c_variant_enter(cv, "a");
                        n = c_variant_peek_count(cv);
                        c_variant_varg_enter_bound(&varg, cv, n);

                        printf("%*sARRAY - %zu {\n", nest * 4, "", n);
                        ++nest;
                        break;
                case C_VARIANT_TUPLE_OPEN:
                        c_variant_enter(cv, "(");
                        c_variant_varg_enter_unbound(&varg, cv, ')');

                        type = c_variant_peek_type(cv, &n);
                        printf("%*s\"(%.*s)\" {\n", nest * 4, "", (int)n, type);
                        ++nest;
                        break;
                case C_VARIANT_PAIR_OPEN:
                        c_variant_enter(cv, "{");
                        c_variant_varg_enter_unbound(&varg, cv, '}');

                        type = c_variant_peek_type(cv, &n);
                        printf("%*s\"{%.*s}\" {\n", nest * 4, "", (int)n, type);
                        ++nest;
                        break;
                case C_VARIANT_INT64:
                        c_variant_read(cv, "x", &u64);
                        printf("%*sINT64: %"PRId64"\n", nest * 4, "", u64);
                        break;
                case C_VARIANT_UINT64:
                        c_variant_read(cv, "t", &u64);
                        printf("%*sUINT64: %"PRIu64"\n", nest * 4, "", u64);
                        break;
                case C_VARIANT_DOUBLE:
                        c_variant_read(cv, "d", &f64);
                        printf("%*sDOUBLE: %f\n", nest * 4, "", f64);
                        break;
                case C_VARIANT_INT32:
                        c_variant_read(cv, "i", &u32);
                        printf("%*sINT32: %"PRId32"\n", nest * 4, "", u32);
                        break;
                case C_VARIANT_UINT32:
                        c_variant_read(cv, "u", &u32);
                        printf("%*sUINT32: %"PRIu32"\n", nest * 4, "", u32);
                        break;
                case C_VARIANT_HANDLE:
                        c_variant_read(cv, "h", &u32);
                        printf("%*sHANDLE: %"PRIu32"\n", nest * 4, "", u32);
                        break;
                case C_VARIANT_INT16:
                        c_variant_read(cv, "n", &u16);
                        printf("%*sINT16: %"PRId16"\n", nest * 4, "", u16);
                        break;
                case C_VARIANT_UINT16:
                        c_variant_read(cv, "q", &u16);
                        printf("%*sUINT16: %"PRIu16"\n", nest * 4, "", u16);
                        break;
                case C_VARIANT_BOOL:
                        c_variant_read(cv, "b", &u8);
                        printf("%*sBOOL: %s\n", nest * 4, "", u8 ? "TRUE" : "FALSE");
                        break;
                case C_VARIANT_BYTE:
                        c_variant_read(cv, "y", &u8);
                        printf("%*sBYTE: %d\n", nest * 4, "", u8);
                        break;
                case C_VARIANT_STRING:
                        c_variant_read(cv, "s", &s);
                        printf("%*sSTRING: %s\n", nest * 4, "", s);
                        break;
                case C_VARIANT_PATH:
                        c_variant_read(cv, "o", &s);
                        printf("%*sPATH: %s\n", nest * 4, "", s);
                        break;
                case C_VARIANT_SIGNATURE:
                        c_variant_read(cv, "g", &s);
                        printf("%*sSIGNATURE: %s\n", nest * 4, "", s);
                        break;
                default:
                        fprintf(stderr, "ERR: %d\n", c);
                        assert(0);
                        break;
                }

                r = c_variant_return_poison(cv);
                assert(r >= 0);
        }
}
コード例 #4
0
ファイル: test-glib.c プロジェクト: larsu/c-variant
static void test_compare(CVariant *cv, GVariant *gv) {
        const GVariantType *gvt;
        GVariantIter gvi[C_VARIANT_MAX_VARG];
        GVariant *gvig[C_VARIANT_MAX_VARG];
        CVariantVarg varg;
        const char *s, *type;
        uint64_t val_64;
        uint32_t val_32;
        uint16_t val_16;
        uint8_t val_8;
        double val_f;
        size_t n, nest;
        GVariant *g;
        int r, c;

        type = c_variant_peek_type(cv, &n);
        gvt = g_variant_get_type(gv);

        assert(n == g_variant_type_get_string_length(gvt));
        assert(!memcmp(type, g_variant_type_peek_string(gvt), n));

        nest = 0;
        g = gv;
        for (c = c_variant_varg_init(&varg, type, n);
             c;
             c = c_variant_varg_next(&varg)) {
                if (c == -1) {
                        r = c_variant_exit(cv, NULL);
                        assert(r >= 0);

                        assert(nest-- > 0);
                        g_variant_unref(gvig[nest]);
                        continue;
                }

                if (nest > 0)
                        g = g_variant_iter_next_value(&gvi[nest - 1]);
                else
                        g = g_variant_ref(gv);
                assert(g);

                switch (c) {
                case C_VARIANT_VARIANT:
                        c_variant_enter(cv, "v");
                        type = c_variant_peek_type(cv, &n);
                        c_variant_varg_push(&varg, type, n, -1);

                        g_variant_iter_init(&gvi[nest], g);
                        gvig[nest] = g_variant_ref(g);
                        ++nest;
                        break;
                case C_VARIANT_MAYBE:
                        c_variant_enter(cv, "m");
                        n = c_variant_peek_count(cv);
                        c_variant_varg_enter_bound(&varg, cv, n);

                        g_variant_iter_init(&gvi[nest], g);
                        gvig[nest] = g_variant_ref(g);
                        ++nest;
                        break;
                case C_VARIANT_ARRAY:
                        c_variant_enter(cv, "a");
                        n = c_variant_peek_count(cv);
                        c_variant_varg_enter_bound(&varg, cv, n);

                        g_variant_iter_init(&gvi[nest], g);
                        gvig[nest] = g_variant_ref(g);
                        ++nest;
                        break;
                case C_VARIANT_TUPLE_OPEN:
                        c_variant_enter(cv, "(");
                        c_variant_varg_enter_unbound(&varg, cv, ')');

                        g_variant_iter_init(&gvi[nest], g);
                        gvig[nest] = g_variant_ref(g);
                        ++nest;
                        break;
                case C_VARIANT_PAIR_OPEN:
                        c_variant_enter(cv, "{");
                        c_variant_varg_enter_unbound(&varg, cv, '}');

                        g_variant_iter_init(&gvi[nest], g);
                        gvig[nest] = g_variant_ref(g);
                        ++nest;
                        break;
                case C_VARIANT_INT64:
                        c_variant_read(cv, "x", &val_64);
                        assert((int64_t)val_64 == g_variant_get_int64(g));
                        break;
                case C_VARIANT_UINT64:
                        c_variant_read(cv, "t", &val_64);
                        assert((uint64_t)val_64 == g_variant_get_uint64(g));
                        break;
                case C_VARIANT_DOUBLE:
                        c_variant_read(cv, "d", &val_f);
                        assert(!(val_f > g_variant_get_double(g)) &&
                               !(val_f < g_variant_get_double(g)));
                        break;
                case C_VARIANT_INT32:
                        c_variant_read(cv, "i", &val_32);
                        assert((int32_t)val_32 == g_variant_get_int32(g));
                        break;
                case C_VARIANT_UINT32:
                        c_variant_read(cv, "u", &val_32);
                        assert((uint32_t)val_32 == g_variant_get_uint32(g));
                        break;
                case C_VARIANT_HANDLE:
                        c_variant_read(cv, "h", &val_32);
                        assert((int32_t)val_32 == g_variant_get_handle(g));
                        break;
                case C_VARIANT_INT16:
                        c_variant_read(cv, "n", &val_16);
                        assert((int16_t)val_16 == g_variant_get_int16(g));
                        break;
                case C_VARIANT_UINT16:
                        c_variant_read(cv, "q", &val_16);
                        assert((uint16_t)val_16 == g_variant_get_uint16(g));
                        break;
                case C_VARIANT_BOOL:
                        c_variant_read(cv, "b", &val_8);
                        assert((bool)val_8 == g_variant_get_boolean(g));
                        break;
                case C_VARIANT_BYTE:
                        c_variant_read(cv, "y", &val_8);
                        assert((guchar)val_8 == g_variant_get_byte(g));
                        break;
                case C_VARIANT_STRING:
                        c_variant_read(cv, "s", &s);
                        assert(!strcmp(s, g_variant_get_string(g, NULL)));
                        break;
                case C_VARIANT_PATH:
                        c_variant_read(cv, "o", &s);
                        assert(!strcmp(s, g_variant_get_string(g, NULL)));
                        break;
                case C_VARIANT_SIGNATURE:
                        c_variant_read(cv, "g", &s);
                        assert(!strcmp(s, g_variant_get_string(g, NULL)));
                        break;
                default:
                        assert(0);
                        break;
                }

                r = c_variant_return_poison(cv);
                assert(r >= 0);

                g_variant_unref(g);
        }
}