static void qdict_crumple_test_recursive(void) { QDict *src, *dst, *rule, *vnc, *acl, *listen; QList *rules; src = qdict_new(); qdict_put(src, "vnc.listen.addr", qstring_from_str("127.0.0.1")); qdict_put(src, "vnc.listen.port", qstring_from_str("5901")); qdict_put(src, "vnc.acl.rules.0.match", qstring_from_str("fred")); qdict_put(src, "vnc.acl.rules.0.policy", qstring_from_str("allow")); qdict_put(src, "vnc.acl.rules.1.match", qstring_from_str("bob")); qdict_put(src, "vnc.acl.rules.1.policy", qstring_from_str("deny")); qdict_put(src, "vnc.acl.default", qstring_from_str("deny")); qdict_put(src, "vnc.acl..name", qstring_from_str("acl0")); qdict_put(src, "vnc.acl.rule..name", qstring_from_str("acl0")); dst = qobject_to_qdict(qdict_crumple(src, &error_abort)); g_assert(dst); g_assert_cmpint(qdict_size(dst), ==, 1); vnc = qdict_get_qdict(dst, "vnc"); g_assert(vnc); g_assert_cmpint(qdict_size(vnc), ==, 3); listen = qdict_get_qdict(vnc, "listen"); g_assert(listen); g_assert_cmpint(qdict_size(listen), ==, 2); g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr")); g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port")); acl = qdict_get_qdict(vnc, "acl"); g_assert(acl); g_assert_cmpint(qdict_size(acl), ==, 3); rules = qdict_get_qlist(acl, "rules"); g_assert(rules); g_assert_cmpint(qlist_size(rules), ==, 2); rule = qobject_to_qdict(qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); QDECREF(rule); rule = qobject_to_qdict(qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); QDECREF(rule); /* With recursive crumpling, we should see all names unescaped */ g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name")); g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name")); QDECREF(src); QDECREF(dst); }
static void handle_io_sched_compl( lsm_state_t *ns, tw_bf *b, lsm_message_t *m_in, tw_lp *lp) { if (LSM_DEBUG) printf("handle_io_sched_compl called\n"); ns->sched.active_count--; if (ns->sched.active_count) { lsm_sched_op_t *next = NULL; struct qlist_head *ent = NULL; for (int i = 0; i < ns->sched.num_prios; i++) { ent = qlist_pop(&ns->sched.queues[i]); if (ent != NULL) { next = qlist_entry(ent, lsm_sched_op_t, ql); m_in->prio = i; break; } } assert(next); handle_io_request(ns, b, &next->data, m_in, lp); // now done with this request metadata rc_stack_push(lp, next, free, ns->sched.freelist); } }
static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs_json, Error **errp) { QList *keypairs; QString *name; QString *value; const char *key; size_t remaining; int ret = 0; if (!keypairs_json) { return ret; } keypairs = qobject_to(QList, qobject_from_json(keypairs_json, &error_abort)); remaining = qlist_size(keypairs) / 2; assert(remaining); while (remaining--) { name = qobject_to(QString, qlist_pop(keypairs)); value = qobject_to(QString, qlist_pop(keypairs)); assert(name && value); key = qstring_get_str(name); ret = rados_conf_set(cluster, key, qstring_get_str(value)); qobject_unref(value); if (ret < 0) { error_setg_errno(errp, -ret, "invalid conf option %s", key); qobject_unref(name); ret = -EINVAL; break; } qobject_unref(name); } qobject_unref(keypairs); return ret; }
static void qobject_from_qlit_test(void) { QObject *obj, *qobj = qobject_from_qlit(&qlit); QDict *qdict; QList *bee; qdict = qobject_to(QDict, qobj); g_assert_cmpint(qdict_get_int(qdict, "foo"), ==, 42); g_assert_cmpstr(qdict_get_str(qdict, "bar"), ==, "hello world"); g_assert(qobject_type(qdict_get(qdict, "baz")) == QTYPE_QNULL); bee = qdict_get_qlist(qdict, "bee"); obj = qlist_pop(bee); g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 43); qobject_unref(obj); obj = qlist_pop(bee); g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 44); qobject_unref(obj); obj = qlist_pop(bee); g_assert(qbool_get_bool(qobject_to(QBool, obj))); qobject_unref(obj); qobject_unref(qobj); }
int rr_next( tw_stime * poffset, void * sched, void * rc_event_save, model_net_sched_rc * rc, tw_lp * lp){ int ret = fcfs_next(poffset, sched, rc_event_save, rc, lp); // if error in fcfs or the request was finished & removed, then nothing to // do here if (ret == -1 || ret == 1) return ret; // otherwise request was successful, still in the queue else { mn_sched_queue *s = sched; qlist_add_tail(qlist_pop(&s->reqs), &s->reqs); return ret; } }
/* 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_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); }
int fcfs_next( tw_stime * poffset, void * sched, void * rc_event_save, model_net_sched_rc * rc, tw_lp * lp){ mn_sched_queue *s = sched; struct qlist_head *ent = s->reqs.next; if (ent == &s->reqs){ rc->rtn = -1; return -1; } mn_sched_qitem *q = qlist_entry(ent, mn_sched_qitem, ql); // issue the next packet int is_last_packet; uint64_t psize; if (q->req.packet_size >= q->rem) { psize = q->rem; is_last_packet = 1; } else{ psize = q->req.packet_size; is_last_packet = 0; } if (s->is_recv_queue){ dprintf("%lu (mn): receiving message of size %lu (of %lu) " "from %lu to %lu at %1.5e (last:%d)\n", lp->gid, psize, q->rem, q->req.src_lp, q->req.final_dest_lp, tw_now(lp), is_last_packet); *poffset = s->method->model_net_method_recv_msg_event(q->req.category, q->req.final_dest_lp, psize, q->req.is_pull, q->req.msg_size, 0.0, q->req.remote_event_size, q->remote_event, q->req.src_lp, lp); } else{ dprintf("%lu (mn): issuing packet of size %lu (of %lu) " "from %lu to %lu at %1.5e (last:%d)\n", lp->gid, psize, q->rem, q->req.src_lp, q->req.final_dest_lp, tw_now(lp), is_last_packet); *poffset = s->method->model_net_method_packet_event(q->req.category, q->req.final_dest_lp, psize, q->req.is_pull, q->req.msg_size, 0.0, &q->sched_params, q->req.remote_event_size, q->remote_event, q->req.self_event_size, q->local_event, q->req.src_lp, lp, is_last_packet); } // if last packet - remove from list, free, save for rc if (is_last_packet){ dprintf("last %spkt: %lu (%lu) to %lu, size %lu at %1.5e (pull:%d)\n", s->is_recv_queue ? "recv " : "send ", lp->gid, q->req.src_lp, q->req.final_dest_lp, q->req.is_pull ? PULL_MSG_SIZE : q->req.msg_size, tw_now(lp), q->req.is_pull); qlist_pop(&s->reqs); s->queue_len--; rc->req = q->req; rc->sched_params = q->sched_params; void *e_dat = rc_event_save; if (q->req.remote_event_size > 0){ memcpy(e_dat, q->remote_event, q->req.remote_event_size); e_dat = (char*) e_dat + q->req.remote_event_size; free(q->remote_event); } if (q->req.self_event_size > 0){ memcpy(e_dat, q->local_event, q->req.self_event_size); free(q->local_event); } free(q); rc->rtn = 1; } else{ q->rem -= psize; rc->rtn = 0; } return rc->rtn; }
static void qdict_crumple_test_recursive(void) { QDict *src, *dst, *rule, *vnc, *acl, *listen; QDict *empty, *empty_dict, *empty_list_0; QList *rules, *empty_list, *empty_dict_a; src = qdict_new(); qdict_put_str(src, "vnc.listen.addr", "127.0.0.1"); qdict_put_str(src, "vnc.listen.port", "5901"); qdict_put_str(src, "vnc.acl.rules.0.match", "fred"); qdict_put_str(src, "vnc.acl.rules.0.policy", "allow"); qdict_put_str(src, "vnc.acl.rules.1.match", "bob"); qdict_put_str(src, "vnc.acl.rules.1.policy", "deny"); qdict_put_str(src, "vnc.acl.default", "deny"); qdict_put_str(src, "vnc.acl..name", "acl0"); qdict_put_str(src, "vnc.acl.rule..name", "acl0"); qdict_put(src, "empty.dict.a", qlist_new()); qdict_put(src, "empty.list.0", qdict_new()); dst = qobject_to(QDict, qdict_crumple(src, &error_abort)); g_assert(dst); g_assert_cmpint(qdict_size(dst), ==, 2); vnc = qdict_get_qdict(dst, "vnc"); g_assert(vnc); g_assert_cmpint(qdict_size(vnc), ==, 3); listen = qdict_get_qdict(vnc, "listen"); g_assert(listen); g_assert_cmpint(qdict_size(listen), ==, 2); g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr")); g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port")); acl = qdict_get_qdict(vnc, "acl"); g_assert(acl); g_assert_cmpint(qdict_size(acl), ==, 3); rules = qdict_get_qlist(acl, "rules"); g_assert(rules); g_assert_cmpint(qlist_size(rules), ==, 2); rule = qobject_to(QDict, qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); qobject_unref(rule); rule = qobject_to(QDict, qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); qobject_unref(rule); /* With recursive crumpling, we should see all names unescaped */ g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name")); g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name")); empty = qdict_get_qdict(dst, "empty"); g_assert(empty); g_assert_cmpint(qdict_size(empty), ==, 2); empty_dict = qdict_get_qdict(empty, "dict"); g_assert(empty_dict); g_assert_cmpint(qdict_size(empty_dict), ==, 1); empty_dict_a = qdict_get_qlist(empty_dict, "a"); g_assert(empty_dict_a && qlist_empty(empty_dict_a)); empty_list = qdict_get_qlist(empty, "list"); g_assert(empty_list); g_assert_cmpint(qlist_size(empty_list), ==, 1); empty_list_0 = qobject_to(QDict, qlist_pop(empty_list)); g_assert(empty_list_0); g_assert_cmpint(qdict_size(empty_list_0), ==, 0); qobject_unref(src); qobject_unref(dst); }