static void test_event_c(TestEventData *data, const void *unused) { QDict *d, *d_data, *d_b; UserDefOne b; b.integer = 2; b.string = g_strdup("test1"); b.has_enum1 = false; d_b = qdict_new(); qdict_put(d_b, "integer", qint_from_int(2)); qdict_put(d_b, "string", qstring_from_str("test1")); d_data = qdict_new(); qdict_put(d_data, "a", qint_from_int(1)); qdict_put(d_data, "b", d_b); qdict_put(d_data, "c", qstring_from_str("test2")); d = data->expect; qdict_put(d, "event", qstring_from_str("EVENT_C")); qdict_put(d, "data", d_data); qapi_event_send_event_c(true, 1, true, &b, "test2", &error_abort); g_free(b.string); }
static void qdict_iterapi_test(void) { int count; const QDictEntry *ent; QDict *tests_dict = qdict_new(); g_assert(qdict_first(tests_dict) == NULL); qdict_put(tests_dict, "key1", qint_from_int(1)); qdict_put(tests_dict, "key2", qint_from_int(2)); qdict_put(tests_dict, "key3", qint_from_int(3)); count = 0; for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){ g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1); count++; } g_assert(count == qdict_size(tests_dict)); /* Do it again to test restarting */ count = 0; for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){ g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1); count++; } g_assert(count == qdict_size(tests_dict)); QDECREF(tests_dict); }
/* test commands that involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QObject *resp; qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); /* TODO: put in full payload and check for errors */ resp = qmp_dispatch(QOBJECT(req)); assert(resp != NULL); assert(!qdict_haskey(qobject_to_qdict(resp), "error")); g_print("\nresp: %s\n", qstring_get_str(qobject_to_json_pretty(resp))); qobject_decref(resp); QDECREF(req); }
static void qdict_put_exists_test(void) { int value; const char *key = "exists"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qint_from_int(1)); qdict_put(tests_dict, key, qint_from_int(2)); value = qdict_get_int(tests_dict, key); g_assert(value == 2); g_assert(qdict_size(tests_dict) == 1); QDECREF(tests_dict); }
/* test commands that return an error due to invalid parameters */ static void test_dispatch_cmd_failure(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); /* check that with extra arguments it throws an error */ req = qdict_new(); qdict_put(args, "a", qint_from_int(66)); qdict_put(req, "arguments", args); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); }
/* test commands that involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *args3 = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QDict *ret, *ret_dict, *ret_dict_dict, *ret_dict_dict_userdef; QDict *ret_dict_dict2, *ret_dict_dict2_userdef; QInt *ret3; qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); ret = qobject_to_qdict(test_qmp_dispatch(req)); assert(!strcmp(qdict_get_str(ret, "string0"), "blah1")); ret_dict = qdict_get_qdict(ret, "dict1"); assert(!strcmp(qdict_get_str(ret_dict, "string1"), "blah2")); ret_dict_dict = qdict_get_qdict(ret_dict, "dict2"); ret_dict_dict_userdef = qdict_get_qdict(ret_dict_dict, "userdef"); assert(qdict_get_int(ret_dict_dict_userdef, "integer") == 42); assert(!strcmp(qdict_get_str(ret_dict_dict_userdef, "string"), "hello")); assert(!strcmp(qdict_get_str(ret_dict_dict, "string"), "blah3")); ret_dict_dict2 = qdict_get_qdict(ret_dict, "dict3"); ret_dict_dict2_userdef = qdict_get_qdict(ret_dict_dict2, "userdef"); assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422); assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2")); assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4")); QDECREF(ret); qdict_put(args3, "a", qint_from_int(66)); qdict_put(req, "arguments", args3); qdict_put(req, "execute", qstring_from_str("guest-get-time")); ret3 = qobject_to_qint(test_qmp_dispatch(req)); assert(qint_get_int(ret3) == 66); QDECREF(ret3); QDECREF(req); }
static void archipelago_parse_filename(const char *filename, QDict *options, Error **errp) { const char *start; char *volume = NULL, *segment_name = NULL; xport mport = NoPort, vport = NoPort; if (qdict_haskey(options, ARCHIPELAGO_OPT_VOLUME) || qdict_haskey(options, ARCHIPELAGO_OPT_SEGMENT) || qdict_haskey(options, ARCHIPELAGO_OPT_MPORT) || qdict_haskey(options, ARCHIPELAGO_OPT_VPORT)) { error_setg(errp, "volume/mport/vport/segment and a file name may not" " be specified at the same time"); return; } if (!strstart(filename, "archipelago:", &start)) { error_setg(errp, "File name must start with 'archipelago:'"); return; } if (!strlen(start) || strstart(start, "/", NULL)) { error_setg(errp, "volume name must be specified"); return; } parse_filename_opts(filename, errp, &volume, &segment_name, &mport, &vport); if (volume) { qdict_put(options, ARCHIPELAGO_OPT_VOLUME, qstring_from_str(volume)); g_free(volume); } if (segment_name) { qdict_put(options, ARCHIPELAGO_OPT_SEGMENT, qstring_from_str(segment_name)); g_free(segment_name); } if (mport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_MPORT, qint_from_int(mport)); } if (vport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_VPORT, qint_from_int(vport)); } }
static void qdict_destroy_simple_test(void) { QDict *qdict; qdict = qdict_new(); qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0))); qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo"))); QDECREF(qdict); }
static void qdict_haskey_test(void) { const char *key = "test"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qint_from_int(0)); g_assert(qdict_haskey(tests_dict, key) == 1); QDECREF(tests_dict); }
static int process_jit_info(QemuHttpConnection *conn) { int i; TranslationBlock *tb; QList *res = qlist_new(); for (i = 0; i < nb_tbs; i++) { tb = &tbs[i]; QList *item = qlist_new(); qlist_append(item, qint_from_int(tb->pc)); qlist_append(item, qint_from_int(tb->size)); qlist_append(item, qint_from_int(tb->flags)); qlist_append(item, qint_from_int(tb->page_addr[1] != -1 ? 1 : 0)); qlist_append(item, qint_from_int(tb->tb_next_offset[0])); qlist_append(item, qint_from_int(tb->tb_next_offset[1])); qlist_append(res, item); } int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static void qdict_get_int_test(void) { int ret; const int value = 100; const char *key = "int"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qint_from_int(value)); ret = qdict_get_int(tests_dict, key); g_assert(ret == value); QDECREF(tests_dict); }
static int process_irq_info(QemuHttpConnection *conn) { int i; int64_t count; QList *res = qlist_new(); for (i = 0; i < 16; ++i) { count = irq_count[i]; qlist_append(res, qint_from_int(count)); } int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static void qdict_get_test(void) { QInt *qi; QObject *obj; const int value = -42; const char *key = "test"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qint_from_int(value)); obj = qdict_get(tests_dict, key); g_assert(obj != NULL); qi = qobject_to_qint(obj); g_assert(qint_get_int(qi) == value); QDECREF(tests_dict); }
/* Complex type */ static void test_event_d(TestEventData *data, const void *unused) { UserDefOne struct1; EventStructOne a; QDict *d, *d_data, *d_a, *d_struct1; struct1.integer = 2; struct1.string = g_strdup("test1"); struct1.has_enum1 = true; struct1.enum1 = ENUM_ONE_VALUE1; a.struct1 = &struct1; a.string = g_strdup("test2"); a.has_enum2 = true; a.enum2 = ENUM_ONE_VALUE2; d_struct1 = qdict_new(); qdict_put(d_struct1, "integer", qint_from_int(2)); qdict_put(d_struct1, "string", qstring_from_str("test1")); qdict_put(d_struct1, "enum1", qstring_from_str("value1")); d_a = qdict_new(); qdict_put(d_a, "struct1", d_struct1); qdict_put(d_a, "string", qstring_from_str("test2")); qdict_put(d_a, "enum2", qstring_from_str("value2")); d_data = qdict_new(); qdict_put(d_data, "a", d_a); qdict_put(d_data, "b", qstring_from_str("test3")); qdict_put(d_data, "enum3", qstring_from_str("value3")); d = data->expect; qdict_put(d, "event", qstring_from_str("EVENT_D")); qdict_put(d, "data", d_data); qapi_event_send_event_d(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3, &error_abort); g_free(struct1.string); g_free(a.string); }
static void qlist_append_test(void) { QInt *qi; QList *qlist; QListEntry *entry; qi = qint_from_int(42); qlist = qlist_new(); qlist_append(qlist, qi); entry = QTAILQ_FIRST(&qlist->head); g_assert(entry != NULL); g_assert(entry->value == QOBJECT(qi)); // destroy doesn't exist yet QDECREF(qi); g_free(entry); g_free(qlist); }
static void qdict_put_obj_test(void) { QInt *qi; QDict *qdict; QDictEntry *ent; const int num = 42; qdict = qdict_new(); // key "" will have tdb hash 12345 qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); g_assert(qdict_size(qdict) == 1); ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]); qi = qobject_to_qint(ent->value); g_assert(qint_get_int(qi) == num); // destroy doesn't exit yet QDECREF(qi); g_free(ent->key); g_free(ent); g_free(qdict); }
static void qdict_flatten_test(void) { QList *list1 = qlist_new(); QList *list2 = qlist_new(); QDict *dict1 = qdict_new(); QDict *dict2 = qdict_new(); QDict *dict3 = qdict_new(); /* * Test the flattening of * * { * "e": [ * 42, * [ * 23, * 66, * { * "a": 0, * "b": 1 * } * ] * ], * "f": { * "c": 2, * "d": 3, * }, * "g": 4 * } * * to * * { * "e.0": 42, * "e.1.0": 23, * "e.1.1": 66, * "e.1.2.a": 0, * "e.1.2.b": 1, * "f.c": 2, * "f.d": 3, * "g": 4 * } */ qdict_put(dict1, "a", qint_from_int(0)); qdict_put(dict1, "b", qint_from_int(1)); qlist_append_obj(list1, QOBJECT(qint_from_int(23))); qlist_append_obj(list1, QOBJECT(qint_from_int(66))); qlist_append_obj(list1, QOBJECT(dict1)); qlist_append_obj(list2, QOBJECT(qint_from_int(42))); qlist_append_obj(list2, QOBJECT(list1)); qdict_put(dict2, "c", qint_from_int(2)); qdict_put(dict2, "d", qint_from_int(3)); qdict_put_obj(dict3, "e", QOBJECT(list2)); qdict_put_obj(dict3, "f", QOBJECT(dict2)); qdict_put(dict3, "g", qint_from_int(4)); qdict_flatten(dict3); g_assert(qdict_get_int(dict3, "e.0") == 42); g_assert(qdict_get_int(dict3, "e.1.0") == 23); g_assert(qdict_get_int(dict3, "e.1.1") == 66); g_assert(qdict_get_int(dict3, "e.1.2.a") == 0); g_assert(qdict_get_int(dict3, "e.1.2.b") == 1); g_assert(qdict_get_int(dict3, "f.c") == 2); g_assert(qdict_get_int(dict3, "f.d") == 3); g_assert(qdict_get_int(dict3, "g") == 4); g_assert(qdict_size(dict3) == 8); QDECREF(dict3); }
static void qdict_array_split_test(void) { QDict *test_dict = qdict_new(); QDict *dict1, *dict2; QInt *int1; QList *test_list; /* * Test the split of * * { * "1.x": 0, * "4.y": 1, * "0.a": 42, * "o.o": 7, * "0.b": 23, * "2": 66 * } * * to * * [ * { * "a": 42, * "b": 23 * }, * { * "x": 0 * }, * 66 * ] * * and * * { * "4.y": 1, * "o.o": 7 * } * * (remaining in the old QDict) * * This example is given in the comment of qdict_array_split(). */ qdict_put(test_dict, "1.x", qint_from_int(0)); qdict_put(test_dict, "4.y", qint_from_int(1)); qdict_put(test_dict, "0.a", qint_from_int(42)); qdict_put(test_dict, "o.o", qint_from_int(7)); qdict_put(test_dict, "0.b", qint_from_int(23)); qdict_put(test_dict, "2", qint_from_int(66)); qdict_array_split(test_dict, &test_list); dict1 = qobject_to_qdict(qlist_pop(test_list)); dict2 = qobject_to_qdict(qlist_pop(test_list)); int1 = qobject_to_qint(qlist_pop(test_list)); g_assert(dict1); g_assert(dict2); g_assert(int1); g_assert(qlist_empty(test_list)); QDECREF(test_list); g_assert(qdict_get_int(dict1, "a") == 42); g_assert(qdict_get_int(dict1, "b") == 23); g_assert(qdict_size(dict1) == 2); QDECREF(dict1); g_assert(qdict_get_int(dict2, "x") == 0); g_assert(qdict_size(dict2) == 1); QDECREF(dict2); g_assert(qint_get_int(int1) == 66); QDECREF(int1); g_assert(qdict_get_int(test_dict, "4.y") == 1); g_assert(qdict_get_int(test_dict, "o.o") == 7); g_assert(qdict_size(test_dict) == 2); QDECREF(test_dict); /* * Test the split of * * { * "0": 42, * "1": 23, * "1.x": 84 * } * * to * * [ * 42 * ] * * and * * { * "1": 23, * "1.x": 84 * } * * That is, test whether splitting stops if there is both an entry with key * of "%u" and other entries with keys prefixed "%u." for the same index. */ test_dict = qdict_new(); qdict_put(test_dict, "0", qint_from_int(42)); qdict_put(test_dict, "1", qint_from_int(23)); qdict_put(test_dict, "1.x", qint_from_int(84)); qdict_array_split(test_dict, &test_list); int1 = qobject_to_qint(qlist_pop(test_list)); g_assert(int1); g_assert(qlist_empty(test_list)); QDECREF(test_list); g_assert(qint_get_int(int1) == 42); QDECREF(int1); g_assert(qdict_get_int(test_dict, "1") == 23); g_assert(qdict_get_int(test_dict, "1.x") == 84); g_assert(qdict_size(test_dict) == 2); QDECREF(test_dict); }
static int parse_uri(const char *filename, QDict *options, Error **errp) { URI *uri = NULL; QueryParams *qp = NULL; int i; uri = uri_parse(filename); if (!uri) { return -EINVAL; } if (strcmp(uri->scheme, "ssh") != 0) { error_setg(errp, "URI scheme must be 'ssh'"); goto err; } if (!uri->server || strcmp(uri->server, "") == 0) { error_setg(errp, "missing hostname in URI"); goto err; } if (!uri->path || strcmp(uri->path, "") == 0) { error_setg(errp, "missing remote path in URI"); goto err; } qp = query_params_parse(uri->query); if (!qp) { error_setg(errp, "could not parse query parameters"); goto err; } if(uri->user && strcmp(uri->user, "") != 0) { qdict_put(options, "user", qstring_from_str(uri->user)); } qdict_put(options, "host", qstring_from_str(uri->server)); if (uri->port) { qdict_put(options, "port", qint_from_int(uri->port)); } qdict_put(options, "path", qstring_from_str(uri->path)); /* Pick out any query parameters that we understand, and ignore * the rest. */ for (i = 0; i < qp->n; ++i) { if (strcmp(qp->p[i].name, "host_key_check") == 0) { qdict_put(options, "host_key_check", qstring_from_str(qp->p[i].value)); } } query_params_free(qp); uri_free(uri); return 0; err: if (qp) { query_params_free(qp); } if (uri) { uri_free(uri); } return -EINVAL; }
static void stat_put(QDict *dict, const char *label, uint64_t val) { if (val != -1) qdict_put(dict, label, qint_from_int(val)); }
/* test core visitor methods */ static void test_visitor_core(void) { QmpOutputVisitor *mo; QmpInputVisitor *mi; Visitor *v; TestStruct ts = { 42, 82 }; TestStruct *pts = &ts; TestStructList *lts = NULL; Error *err = NULL; QObject *obj; QList *qlist; QDict *qdict; QString *str; int64_t value = 0; mo = qmp_output_visitor_new(); v = qmp_output_get_visitor(mo); visit_type_TestStruct(v, &pts, NULL, &err); obj = qmp_output_get_qobject(mo); str = qobject_to_json(obj); printf("%s\n", qstring_get_str(str)); QDECREF(str); obj = QOBJECT(qint_from_int(0x42)); mi = qmp_input_visitor_new(obj); v = qmp_input_get_visitor(mi); visit_type_int(v, &value, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } g_assert(value == 0x42); qobject_decref(obj); obj = qobject_from_json("{'x': 42, 'y': 84}"); mi = qmp_input_visitor_new(obj); v = qmp_input_get_visitor(mi); pts = NULL; visit_type_TestStruct(v, &pts, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } g_assert(pts != NULL); g_assert(pts->x == 42); g_assert(pts->y == 84); qobject_decref(obj); g_free(pts); /* test list input visitor */ obj = qobject_from_json("[{'x': 42, 'y': 84}, {'x': 12, 'y': 24}]"); mi = qmp_input_visitor_new(obj); v = qmp_input_get_visitor(mi); visit_type_TestStructList(v, <s, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } g_assert(lts != NULL); g_assert(lts->value->x == 42); g_assert(lts->value->y == 84); g_assert(lts->next != NULL); g_assert(lts->next->value->x == 12); g_assert(lts->next->value->y == 24); g_assert(lts->next->next == NULL); qobject_decref(obj); /* test list output visitor */ mo = qmp_output_visitor_new(); v = qmp_output_get_visitor(mo); visit_type_TestStructList(v, <s, NULL, &err); if (err) { g_error("%s", error_get_pretty(err)); } obj = qmp_output_get_qobject(mo); g_print("obj: %s\n", qstring_get_str(qobject_to_json(obj))); qlist = qobject_to_qlist(obj); assert(qlist); obj = qlist_pop(qlist); qdict = qobject_to_qdict(obj); assert(qdict); assert(qdict_get_int(qdict, "x") == 42); assert(qdict_get_int(qdict, "y") == 84); qobject_decref(obj); obj = qlist_pop(qlist); qdict = qobject_to_qdict(obj); assert(qdict); assert(qdict_get_int(qdict, "x") == 12); assert(qdict_get_int(qdict, "y") == 24); qobject_decref(obj); qmp_output_visitor_cleanup(mo); QDECREF(qlist); }
static void qdict_array_entries_test(void) { QDict *dict = qdict_new(); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0); qdict_put(dict, "bar", qint_from_int(0)); qdict_put(dict, "baz.0", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0); qdict_put(dict, "foo.1", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL); qdict_put(dict, "foo.0", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2); qdict_put(dict, "foo.bar", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL); qdict_del(dict, "foo.bar"); qdict_put(dict, "foo.2.a", qint_from_int(0)); qdict_put(dict, "foo.2.b", qint_from_int(0)); qdict_put(dict, "foo.2.c", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); QDECREF(dict); dict = qdict_new(); qdict_put(dict, "1", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); qdict_put(dict, "0", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2); qdict_put(dict, "bar", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); qdict_del(dict, "bar"); qdict_put(dict, "2.a", qint_from_int(0)); qdict_put(dict, "2.b", qint_from_int(0)); qdict_put(dict, "2.c", qint_from_int(0)); g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3); QDECREF(dict); }
static int process_cpu_info(QemuHttpConnection *conn) { CPUState *env; QList *cpu_list; int i; cpu_list = qlist_new(); for (env = first_cpu; env != NULL; env = env->next_cpu) { QDict *cpu; QObject *obj; obj = qobject_from_jsonf("{ 'CPU': %d }", env->cpu_index); cpu = qobject_to_qdict(obj); qdict_put(cpu, "eip", qint_from_int(env->eip + env->segs[R_CS].base)); qdict_put(cpu, "eax", qint_from_int(EAX)); qdict_put(cpu, "ebx", qint_from_int(EBX)); qdict_put(cpu, "ecx", qint_from_int(ECX)); qdict_put(cpu, "edx", qint_from_int(EDX)); qdict_put(cpu, "esp", qint_from_int(ESP)); qdict_put(cpu, "ebp", qint_from_int(EBP)); qdict_put(cpu, "esi", qint_from_int(ESI)); qdict_put(cpu, "edi", qint_from_int(EDI)); qdict_put(cpu, "dt", qint_from_int(dev_time)); qdict_put(cpu, "qt", qint_from_int(qemu_time)); #ifdef CONFIG_PROFILER qdict_put(cpu, "tb_count", qint_from_int(tcg_ctx.tb_count)); qdict_put(cpu, "tb_count1", qint_from_int(tcg_ctx.tb_count1)); qdict_put(cpu, "op_count", qint_from_int(tcg_ctx.op_count)); qdict_put(cpu, "op_count_max", qint_from_int(tcg_ctx.op_count_max)); qdict_put(cpu, "temp_count", qint_from_int(tcg_ctx.temp_count)); qdict_put(cpu, "temp_count_max", qint_from_int(tcg_ctx.temp_count_max)); qdict_put(cpu, "del_op_count", qint_from_int(tcg_ctx.del_op_count)); qdict_put(cpu, "code_in_len", qint_from_int(tcg_ctx.code_in_len)); qdict_put(cpu, "code_out_len", qint_from_int(tcg_ctx.code_out_len)); qdict_put(cpu, "interm_time", qint_from_int(tcg_ctx.interm_time)); qdict_put(cpu, "code_time", qint_from_int(tcg_ctx.code_time)); qdict_put(cpu, "la_time", qint_from_int(tcg_ctx.la_time)); qdict_put(cpu, "restore_count", qint_from_int(tcg_ctx.restore_count)); qdict_put(cpu, "restore_time", qint_from_int(tcg_ctx.restore_time)); for (i = INDEX_op_end; i < NB_OPS; i++) { qdict_put(cpu, tcg_op_defs[i].name, qint_from_int(tcg_table_op_count[i])); } #endif qlist_append(cpu_list, cpu); } int st = 0; st = respond_with_json(conn, QOBJECT(cpu_list)); qobject_decref(QOBJECT(cpu_list)); return st; }
static void qdict_join_test(void) { QDict *dict1, *dict2; bool overwrite = false; int i; dict1 = qdict_new(); dict2 = qdict_new(); /* Test everything once without overwrite and once with */ do { /* Test empty dicts */ qdict_join(dict1, dict2, overwrite); g_assert(qdict_size(dict1) == 0); g_assert(qdict_size(dict2) == 0); /* First iteration: Test movement */ /* Second iteration: Test empty source and non-empty destination */ qdict_put(dict2, "foo", qint_from_int(42)); for (i = 0; i < 2; i++) { qdict_join(dict1, dict2, overwrite); g_assert(qdict_size(dict1) == 1); g_assert(qdict_size(dict2) == 0); g_assert(qdict_get_int(dict1, "foo") == 42); } /* Test non-empty source and destination without conflict */ qdict_put(dict2, "bar", qint_from_int(23)); qdict_join(dict1, dict2, overwrite); g_assert(qdict_size(dict1) == 2); g_assert(qdict_size(dict2) == 0); g_assert(qdict_get_int(dict1, "foo") == 42); g_assert(qdict_get_int(dict1, "bar") == 23); /* Test conflict */ qdict_put(dict2, "foo", qint_from_int(84)); qdict_join(dict1, dict2, overwrite); g_assert(qdict_size(dict1) == 2); g_assert(qdict_size(dict2) == !overwrite); g_assert(qdict_get_int(dict1, "foo") == overwrite ? 84 : 42); g_assert(qdict_get_int(dict1, "bar") == 23); if (!overwrite) { g_assert(qdict_get_int(dict2, "foo") == 84); } /* Check the references */ g_assert(qdict_get(dict1, "foo")->refcnt == 1); g_assert(qdict_get(dict1, "bar")->refcnt == 1); if (!overwrite) { g_assert(qdict_get(dict2, "foo")->refcnt == 1); } /* Clean up */ qdict_del(dict1, "foo"); qdict_del(dict1, "bar"); if (!overwrite) { qdict_del(dict2, "foo"); } } while (overwrite ^= true); QDECREF(dict1); QDECREF(dict2); }