自学教程：C++ CU_ASSERT_FATAL函数代码示例

static void vector_2(void) {    vector_t v;    CU_ASSERT(vector_init(&v, "my_vector.bin", 1) == 0);    CU_ASSERT(vector_size(&v) == 0);    CU_ASSERT(vector_pages(&v) == 0);    CU_ASSERT(vector_capacity(&v) == 0);    CU_ASSERT(vector_elem_size(&v) == 1);    CU_ASSERT(vector_size(&v, COUNT) == COUNT);    CU_ASSERT(COUNT <= vector_capacity(&v));    CU_ASSERT(COUNT <= vector_size(&v));    CU_ASSERT(3 <= vector_pages(&v));    for (int i=0; i<COUNT; i++) {        unsigned char c = (unsigned char)i;        crc2 = clib_crc32(c, crc2);        CU_ASSERT(vector_put(&v, i, &c) == 0);    }    CU_ASSERT_FATAL(crc2 != 0);    FILE * f = fopen(v.hdr.name, "w");    CU_ASSERT_FATAL(f != NULL);    CU_ASSERT(COUNT < vector_save(&v, f));    fclose(f), f = NULL;    CU_ASSERT(vector_delete(&v) == 0);}

static void reset_queues(thread_args_t *args){	int i, j, k;	int num_prio = args->num_prio;	int num_queues = args->num_queues;	char name[32];	for (i = 0; i < num_prio; i++) {		for (j = 0; j < num_queues; j++) {			odp_queue_t queue;			snprintf(name, sizeof(name),				 "sched_%d_%d_o", i, j);			queue = odp_queue_lookup(name);			CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);			for (k = 0; k < args->num_bufs; k++) {				queue_context *qctx =					odp_queue_context(queue);				int ndx;				int ndx_max;				ndx_max = odp_queue_lock_count(queue);				CU_ASSERT_FATAL(ndx_max >= 0);				qctx->sequence = 0;				for (ndx = 0; ndx < ndx_max; ndx++)					qctx->lock_sequence[ndx] = 0;			}		}	}}

void pktio_test_send_on_ronly(void){	odp_pktio_t pktio;	odp_packet_t pkt;	int ret;	pktio = create_pktio(0, ODP_PKTIN_MODE_RECV,			     ODP_PKTOUT_MODE_DISABLED);	if (pktio == ODP_PKTIO_INVALID) {		CU_FAIL("failed to open pktio");		return;	}	ret = odp_pktio_start(pktio);	CU_ASSERT_FATAL(ret == 0);	pkt = odp_packet_alloc(default_pkt_pool, packet_len);	CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID)	pktio_init_packet(pkt);	ret = odp_pktio_send(pktio, &pkt, 1);	CU_ASSERT(ret < 0);	if (ret <= 0)		odp_packet_free(pkt);	ret = odp_pktio_stop(pktio);	CU_ASSERT_FATAL(ret == 0);	ret = odp_pktio_close(pktio);	CU_ASSERT_FATAL(ret == 0);}

static voidmmapAndParse(char *path, int expected){	int					fd, ret;	struct toml_node	*root;	void				*m;	struct stat			st;	toml_init(&root);	fd = open(path, O_RDONLY);	CU_ASSERT_FATAL(fd != -1);	ret = fstat(fd, &st);	CU_ASSERT_FATAL(ret != -1);	m = mmap(NULL, st.st_size, PROT_READ, MAP_FILE|MAP_PRIVATE, fd, 0);	CU_ASSERT_FATAL(m != NULL);	ret = toml_parse(root, m, st.st_size);	CU_ASSERT(ret == expected);	munmap(m, st.st_size);	close(fd);	toml_free(root);}

void timer_test_timeout_pool_free(void){	odp_pool_t pool;	odp_timeout_t tmo;	odp_pool_param_t params;	odp_pool_param_init(&params);	params.type    = ODP_POOL_TIMEOUT;	params.tmo.num = 1;	pool = odp_pool_create("timeout_pool_free", &params);	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);	odp_pool_print(pool);	/* Allocate the only timeout from the pool */	tmo = odp_timeout_alloc(pool);	CU_ASSERT_FATAL(tmo != ODP_TIMEOUT_INVALID);	/* Pool should have only one timeout */	CU_ASSERT_FATAL(odp_timeout_alloc(pool) == ODP_TIMEOUT_INVALID)	odp_timeout_free(tmo);	/* Check that the timeout was returned back to the pool */	tmo = odp_timeout_alloc(pool);	CU_ASSERT_FATAL(tmo != ODP_TIMEOUT_INVALID);	odp_timeout_free(tmo);	CU_ASSERT(odp_pool_destroy(pool) == 0);}

void classification_test_destroy_cos(void){	odp_cos_t cos;	char name[ODP_COS_NAME_LEN];	odp_pool_t pool;	odp_queue_t queue;	odp_cls_cos_param_t cls_param;	int retval;	pool = pool_create("cls_basic_pool");	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);	queue = queue_create("cls_basic_queue", true);	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);	sprintf(name, "ClassOfService");	odp_cls_cos_param_init(&cls_param);	cls_param.pool = pool;	cls_param.queue = queue;	cls_param.drop_policy = ODP_COS_DROP_POOL;	cos = odp_cls_cos_create(name, &cls_param);	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);	retval = odp_cos_destroy(cos);	CU_ASSERT(retval == 0);	retval = odp_cos_destroy(ODP_COS_INVALID);	CU_ASSERT(retval < 0);	odp_pool_destroy(pool);	odp_queue_destroy(queue);}

static void vector_3(void) {    vector_t v;    vector_init(&v, __func__, 1);    CU_ASSERT(vector_size(&v) == 0);    CU_ASSERT(vector_pages(&v) == 0);    CU_ASSERT(vector_capacity(&v) == 0);    CU_ASSERT(vector_elem_size(&v) == 1);    FILE * f = fopen("my_vector.bin", "r");    CU_ASSERT_FATAL(f != NULL);    CU_ASSERT(COUNT < vector_load(&v, f));    fclose(f), f = NULL;    crc3 = 0;    for (int i=0; i<COUNT; i++) {        unsigned char c;        vector_get(&v, i, &c);        crc3 = clib_crc32(c, crc3);    }    CU_ASSERT_FATAL(crc3 != 0);    CU_ASSERT_FATAL(crc2 == crc3);    vector_delete(&v);}

void list_test_queue(void) {    /* Reject invalid inputs */    CU_ASSERT(dslist_enqueue(NULL, "Non-null value") == false);    CU_ASSERT(dslist_enqueue(list_test, NULL) == false);    CU_ASSERT(dslist_dequeue(NULL) == NULL);    /* Queue up a bunch of strings */    for (int i = 0; i < 10; i++) {        char *fmt = "Str %d";        char *val = malloc(strlen(fmt) + 1);        CU_ASSERT_FATAL(val != NULL);        sprintf(val, fmt, i);        CU_ASSERT(dslist_enqueue(list_test, val) == true);        CU_ASSERT(dslist_len(list_test) == i+1);    }    /* Dequeue the previous strings */    for (int i = 0; i < 10; i++) {        char *fmt = "Str %d";        char *val = malloc(strlen(fmt) + 1);        CU_ASSERT_FATAL(val != NULL);        sprintf(val, fmt, i);        char *tmp = dslist_dequeue(list_test);        CU_ASSERT(tmp != NULL);        CU_ASSERT(dslist_len(list_test) == (9-i));        CU_ASSERT(strcmp(tmp, val) == 0);        free(tmp);        free(val);    }}

void classification_test_cos_set_drop(void){	int retval;	char cosname[ODP_COS_NAME_LEN];	odp_cos_t cos_drop;	odp_queue_t queue;	odp_pool_t pool;	odp_cls_cos_param_t cls_param;	pool = pool_create("cls_basic_pool");	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);	queue = queue_create("cls_basic_queue", true);	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);	sprintf(cosname, "CoSDrop");	odp_cls_cos_param_init(&cls_param);	cls_param.pool = pool;	cls_param.queue = queue;	cls_param.drop_policy = ODP_COS_DROP_POOL;	cos_drop = odp_cls_cos_create(cosname, &cls_param);	CU_ASSERT_FATAL(cos_drop != ODP_COS_INVALID);	retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_POOL);	CU_ASSERT(retval == 0);	retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_NEVER);	CU_ASSERT(retval == 0);	odp_cos_destroy(cos_drop);	odp_pool_destroy(pool);	odp_queue_destroy(queue);}

void configure_pktio_default_cos(void){	int retval;	odp_queue_param_t qparam;	char cosname[ODP_COS_NAME_LEN];	char queuename[ODP_QUEUE_NAME_LEN];	sprintf(cosname, "DefaultCoS");	cos_list[CLS_DEFAULT] = odp_cos_create(cosname);	CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);	qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;	qparam.sched.sync = ODP_SCHED_SYNC_NONE;	qparam.sched.group = ODP_SCHED_GROUP_ALL;	sprintf(queuename, "%s", "DefaultQueue");	queue_list[CLS_DEFAULT] = odp_queue_create(queuename,					 ODP_QUEUE_TYPE_SCHED, &qparam);	CU_ASSERT_FATAL(queue_list[CLS_DEFAULT] != ODP_QUEUE_INVALID);	retval = odp_cos_set_queue(cos_list[CLS_DEFAULT],				   queue_list[CLS_DEFAULT]);	CU_ASSERT(retval == 0);	retval = odp_pktio_default_cos_set(pktio_loop, cos_list[CLS_DEFAULT]);	CU_ASSERT(retval == 0);}

void configure_pktio_error_cos(void){	int retval;	odp_queue_param_t qparam;	char queuename[ODP_QUEUE_NAME_LEN];	char cosname[ODP_COS_NAME_LEN];	qparam.sched.prio = ODP_SCHED_PRIO_LOWEST;	qparam.sched.sync = ODP_SCHED_SYNC_NONE;	qparam.sched.group = ODP_SCHED_GROUP_ALL;	sprintf(queuename, "%s", "ErrorCos");	queue_list[CLS_ERROR] = odp_queue_create(queuename,						 ODP_QUEUE_TYPE_SCHED,						 &qparam);	CU_ASSERT_FATAL(queue_list[CLS_ERROR] != ODP_QUEUE_INVALID);	sprintf(cosname, "%s", "ErrorCos");	cos_list[CLS_ERROR] = odp_cos_create(cosname);	CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);	retval = odp_cos_set_queue(cos_list[CLS_ERROR], queue_list[CLS_ERROR]);	CU_ASSERT(retval == 0);	retval = odp_pktio_error_cos_set(pktio_loop, cos_list[CLS_ERROR]);	CU_ASSERT(retval == 0);}

void list_test_iter(void) {    int num_iters = 0;    DSList *list = dslist_new((dslist_compare_fn) dsbuf_compare,                               (dslist_free_fn) dsbuf_destroy);    CU_ASSERT_FATAL(list != NULL);    for (int i = 0; i < 6; i++) {        char *some = "Test %d";        char *next = malloc(strlen(some) + 1);        CU_ASSERT_FATAL(next != NULL);        sprintf(next, some, i);        DSBuffer *buf = dsbuf_new(next);        CU_ASSERT_FATAL(buf != NULL);        free(next);        CU_ASSERT(dslist_append(list, buf) == true);        num_iters++;    }    DSIter *iter = dslist_iter(list);    CU_ASSERT_FATAL(iter != NULL);    CU_ASSERT(dsiter_has_next(iter) == true);    int count_iters = 0;    while(dsiter_next(iter)) {        CU_ASSERT(dsiter_key(iter) == NULL);    // Always NULL for lists        CU_ASSERT(dsiter_value(iter) != NULL);        count_iters++;    }    CU_ASSERT(count_iters == num_iters);    CU_ASSERT(dsiter_has_next(iter) == false);    dsiter_destroy(iter);    dslist_destroy(list);}

void test_class_db_result_list(void) {    db_result_t* local_result = result;    db_result_t* local_result2 = result2;    CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new()));    CU_ASSERT_FATAL(!db_result_list_add(result_list, result));    result = NULL;    CU_ASSERT_FATAL(!db_result_list_add(result_list, result2));    result2 = NULL;    CU_ASSERT(db_result_list_size(result_list) == 2);    CU_ASSERT(db_result_list_begin(result_list) == local_result);    CU_ASSERT(db_result_list_next(result_list) == local_result2);    db_result_list_free(result_list);    result_list = NULL;    CU_PASS("db_result_list_free");    CU_PASS("db_result_free");    CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new()));    CU_ASSERT_FATAL(!db_result_list_set_next(result_list, __db_result_list_next, &fake_pointer, 2));    CU_ASSERT(db_result_list_size(result_list) == 2);    CU_ASSERT_PTR_NOT_NULL(db_result_list_begin(result_list));    CU_ASSERT_PTR_NOT_NULL(db_result_list_next(result_list));    db_result_list_free(result_list);    result_list = NULL;    CU_PASS("db_result_list_free");    CU_PASS("db_result_free");}

void test_class_db_backend_meta_data_list(void) {    db_backend_meta_data_t* local_backend_meta_data = backend_meta_data;    db_backend_meta_data_t* local_backend_meta_data2 = backend_meta_data2;    db_backend_meta_data_t* local_backend_meta_data3 = backend_meta_data3;    db_backend_meta_data_t* local_backend_meta_data4 = backend_meta_data4;    CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list = db_backend_meta_data_list_new()));    CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list, backend_meta_data));    backend_meta_data = NULL;    CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list, backend_meta_data2));    backend_meta_data2 = NULL;    CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list, "name1") == local_backend_meta_data);    CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list, "name2") == local_backend_meta_data2);    CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list2 = db_backend_meta_data_list_new()));    CU_ASSERT_FATAL(!db_backend_meta_data_list_copy(backend_meta_data_list2, backend_meta_data_list));    CU_ASSERT_PTR_NOT_NULL(db_backend_meta_data_list_find(backend_meta_data_list2, "name1"));    CU_ASSERT_PTR_NOT_NULL(db_backend_meta_data_list_find(backend_meta_data_list2, "name2"));    db_backend_meta_data_list_free(backend_meta_data_list2);    backend_meta_data_list2 = NULL;    CU_PASS("db_backend_meta_data_list_free");    CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list2 = db_backend_meta_data_list_new()));    CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list2, backend_meta_data3));    backend_meta_data3 = NULL;    CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list2, backend_meta_data4));    backend_meta_data4 = NULL;    CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list2, "name3") == local_backend_meta_data3);    CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list2, "name4") == local_backend_meta_data4);}

static int chaos_thread(void *arg){	uint64_t i, wait;	int rc;	chaos_buf *cbuf;	odp_event_t ev;	odp_queue_t from;	thread_args_t *args = (thread_args_t *)arg;	test_globals_t *globals = args->globals;	int me = odp_thread_id();	odp_time_t start_time, end_time, diff;	if (CHAOS_DEBUG)		printf("Chaos thread %d starting.../n", me);	/* Wait for all threads to start */	odp_barrier_wait(&globals->barrier);	start_time = odp_time_local();	/* Run the test */	wait = odp_schedule_wait_time(5 * ODP_TIME_MSEC_IN_NS);	for (i = 0; i < CHAOS_NUM_ROUNDS; i++) {		ev = odp_schedule(&from, wait);		if (ev == ODP_EVENT_INVALID)			continue;		cbuf = odp_buffer_addr(odp_buffer_from_event(ev));		CU_ASSERT_FATAL(cbuf != NULL);		if (CHAOS_DEBUG)			printf("Thread %d received event %" PRIu64			       " seq %" PRIu64			       " from Q %s, sending to Q %s/n",			       me, cbuf->evno, cbuf->seqno,			       globals->			       chaos_q			       [CHAOS_PTR_TO_NDX(odp_queue_context(from))].name,			       globals->			       chaos_q[cbuf->seqno % CHAOS_NUM_QUEUES].name);		rc = odp_queue_enq(			globals->			chaos_q[cbuf->seqno++ % CHAOS_NUM_QUEUES].handle,			ev);		CU_ASSERT_FATAL(rc == 0);	}	if (CHAOS_DEBUG)		printf("Thread %d completed %d rounds...terminating/n",		       odp_thread_id(), CHAOS_NUM_EVENTS);	exit_schedule_loop();	end_time = odp_time_local();	diff = odp_time_diff(end_time, start_time);	printf("Thread %d ends, elapsed time = %" PRIu64 "us/n",	       odp_thread_id(), odp_time_to_ns(diff) / 1000);	return 0;}

void pktio_test_recv_on_wonly(void){	odp_pktio_t pktio;	odp_packet_t pkt;	int ret;	pktio = create_pktio(0, ODP_PKTIN_MODE_DISABLED,			     ODP_PKTOUT_MODE_SEND);	if (pktio == ODP_PKTIO_INVALID) {		CU_FAIL("failed to open pktio");		return;	}	ret = odp_pktio_start(pktio);	CU_ASSERT_FATAL(ret == 0);	ret = odp_pktio_recv(pktio, &pkt, 1);	CU_ASSERT(ret < 0);	if (ret > 0)		odp_packet_free(pkt);	ret = odp_pktio_stop(pktio);	CU_ASSERT_FATAL(ret == 0);	ret = odp_pktio_close(pktio);	CU_ASSERT_FATAL(ret == 0);}

void scheduler_test_pause_resume(void){	odp_queue_t queue;	odp_buffer_t buf;	odp_event_t ev;	odp_queue_t from;	int i;	int local_bufs = 0;	queue = odp_queue_lookup("sched_0_0_n");	CU_ASSERT(queue != ODP_QUEUE_INVALID);	pool = odp_pool_lookup(MSG_POOL_NAME);	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);	for (i = 0; i < NUM_BUFS_PAUSE; i++) {		buf = odp_buffer_alloc(pool);		CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);		ev = odp_buffer_to_event(buf);		if (odp_queue_enq(queue, ev))			odp_buffer_free(buf);	}	for (i = 0; i < NUM_BUFS_BEFORE_PAUSE; i++) {		from = ODP_QUEUE_INVALID;		ev = odp_schedule(&from, ODP_SCHED_WAIT);		CU_ASSERT(from == queue);		buf = odp_buffer_from_event(ev);		odp_buffer_free(buf);	}	odp_schedule_pause();	while (1) {		ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);		if (ev == ODP_EVENT_INVALID)			break;		CU_ASSERT(from == queue);		buf = odp_buffer_from_event(ev);		odp_buffer_free(buf);		local_bufs++;	}	CU_ASSERT(local_bufs < NUM_BUFS_PAUSE - NUM_BUFS_BEFORE_PAUSE);	odp_schedule_resume();	for (i = local_bufs + NUM_BUFS_BEFORE_PAUSE; i < NUM_BUFS_PAUSE; i++) {		ev = odp_schedule(&from, ODP_SCHED_WAIT);		CU_ASSERT(from == queue);		buf = odp_buffer_from_event(ev);		odp_buffer_free(buf);	}	CU_ASSERT(exit_schedule_loop() == 0);}

/* @private Handle a received (timeout) event */static void handle_tmo(odp_event_t ev, bool stale, uint64_t prev_tick){	CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID); /* Internal error */	if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {		/* Not a timeout event */		CU_FAIL("Unexpected event type received");		return;	}	/* Read the metadata from the timeout */	odp_timeout_t tmo = odp_timeout_from_event(ev);	odp_timer_t tim = odp_timeout_timer(tmo);	uint64_t tick = odp_timeout_tick(tmo);	struct test_timer *ttp = odp_timeout_user_ptr(tmo);	if (tim == ODP_TIMER_INVALID)		CU_FAIL("odp_timeout_timer() invalid timer");	if (!ttp)		CU_FAIL("odp_timeout_user_ptr() null user ptr");	if (ttp && ttp->ev2 != ev)		CU_FAIL("odp_timeout_user_ptr() wrong user ptr");	if (ttp && ttp->tim != tim)		CU_FAIL("odp_timeout_timer() wrong timer");	if (stale) {		if (odp_timeout_fresh(tmo))			CU_FAIL("Wrong status (fresh) for stale timeout");		/* Stale timeout => local timer must have invalid tick */		if (ttp && ttp->tick != TICK_INVALID)			CU_FAIL("Stale timeout for active timer");	} else {		if (!odp_timeout_fresh(tmo))			CU_FAIL("Wrong status (stale) for fresh timeout");		/* Fresh timeout => local timer must have matching tick */		if (ttp && ttp->tick != tick) {			LOG_DBG("Wrong tick: expected %" PRIu64				" actual %" PRIu64 "/n",				ttp->tick, tick);			CU_FAIL("odp_timeout_tick() wrong tick");		}		/* Check that timeout was delivered 'timely' */		if (tick > odp_timer_current_tick(tp))			CU_FAIL("Timeout delivered early");		if (tick < prev_tick) {			LOG_DBG("Too late tick: %" PRIu64				" prev_tick %" PRIu64"/n",				tick, prev_tick);			/* We don't report late timeouts using CU_FAIL */			odp_atomic_inc_u32(&ndelivtoolate);		}	}	if (ttp) {		/* Internal error */		CU_ASSERT_FATAL(ttp->ev == ODP_EVENT_INVALID);		ttp->ev = ev;	}}

void test_array_get(void) {    CU_ASSERT_FATAL(array_get(&test_array, 0) != NULL)    CU_ASSERT(array_get(&test_array, 1) == NULL);    CU_ASSERT_FATAL(array_get(&test_array, 0) == test_ptr);    char *value = array_get(&test_array, 0);    for(int i = 0; i < TEST_STR_SIZE; i++) {        CU_ASSERT(value[i] == 1);    }}

void scheduler_test_wait_time(void){	int i;	odp_queue_t queue;	uint64_t wait_time;	odp_queue_param_t qp;	odp_time_t lower_limit, upper_limit;	odp_time_t start_time, end_time, diff;	/* check on read */	wait_time = odp_schedule_wait_time(0);	wait_time = odp_schedule_wait_time(1);	/* check ODP_SCHED_NO_WAIT */	odp_queue_param_init(&qp);	qp.type        = ODP_QUEUE_TYPE_SCHED;	qp.sched.sync  = ODP_SCHED_SYNC_PARALLEL;	qp.sched.prio  = ODP_SCHED_PRIO_NORMAL;	qp.sched.group = ODP_SCHED_GROUP_ALL;	queue = odp_queue_create("dummy_queue", &qp);	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);	wait_time = odp_schedule_wait_time(ODP_TIME_SEC_IN_NS);	start_time = odp_time_local();	odp_schedule(&queue, ODP_SCHED_NO_WAIT);	end_time = odp_time_local();	diff = odp_time_diff(end_time, start_time);	lower_limit = ODP_TIME_NULL;	upper_limit = odp_time_local_from_ns(ODP_WAIT_TOLERANCE);	CU_ASSERT(odp_time_cmp(diff, lower_limit) >= 0);	CU_ASSERT(odp_time_cmp(diff, upper_limit) <= 0);	/* check time correctness */	start_time = odp_time_local();	for (i = 1; i < 6; i++) {		odp_schedule(&queue, wait_time);		printf("%d..", i);	}	end_time = odp_time_local();	diff = odp_time_diff(end_time, start_time);	lower_limit = odp_time_local_from_ns(5 * ODP_TIME_SEC_IN_NS -							ODP_WAIT_TOLERANCE);	upper_limit = odp_time_local_from_ns(5 * ODP_TIME_SEC_IN_NS +							ODP_WAIT_TOLERANCE);	CU_ASSERT(odp_time_cmp(diff, lower_limit) >= 0);	CU_ASSERT(odp_time_cmp(diff, upper_limit) <= 0);	CU_ASSERT_FATAL(odp_queue_destroy(queue) == 0);}

void testPayload() {	// test for both buffer and dynamic	CoapPDU *pdu = NULL;	uint8_t *buffer[32];	for(int i=0; i<4; i++) {		switch(i) {			case 0:				pdu = new CoapPDU((uint8_t*)buffer,32,0);			break;			case 1:				pdu->reset();			break;			case 2:				pdu = new CoapPDU();			break;			case 3:				pdu->reset();			break;		}		pdu->setType(CoapPDU::COAP_CONFIRMABLE);		pdu->printBin();		pdu->setCode(CoapPDU::COAP_GET);		pdu->setVersion(1);		pdu->printBin();		pdu->setMessageID(0x1234);		pdu->setURI((char*)"test",4);		pdu->printBin();		CU_ASSERT_FATAL(pdu->setPayload(NULL,4)==1);		CU_ASSERT_FATAL(pdu->setPayload((uint8_t*)"test",0)==1);		pdu->setPayload((uint8_t*)"/1/2/3",3);		pdu->printBin();		CU_ASSERT_EQUAL_FATAL(pdu->getPayloadLength(),3);		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPDUPointer(),payloadTestPDUA,pdu->getPDULength());		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPayloadPointer(),"/1/2/3",pdu->getPayloadLength());		DBG("Trying to increase payload size");		pdu->setPayload((uint8_t*)"/4/3/2/1",4);		pdu->printBin();		CU_ASSERT_EQUAL_FATAL(pdu->getPayloadLength(),4);		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPDUPointer(),payloadTestPDUB,pdu->getPDULength());		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPayloadPointer(),"/4/3/2/1",pdu->getPayloadLength());		DBG("Trying to reduce payload size");		pdu->setPayload((uint8_t*)"/1/2",2);		pdu->printBin();		CU_ASSERT_EQUAL_FATAL(pdu->getPayloadLength(),2);		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPDUPointer(),payloadTestPDUC,pdu->getPDULength());		CU_ASSERT_NSTRING_EQUAL_FATAL(pdu->getPayloadPointer(),"/1/2",pdu->getPayloadLength());		if(i%2) {			DBG("%d DELETE",i);			delete pdu;		}	}}

void configure_pktio_pmr_match_set_cos(void){	int retval;	odp_pmr_match_t pmr_terms[2];	uint16_t val;	uint16_t maskport;	int num_terms = 2; /* one pmr for each L3 and L4 */	odp_queue_param_t qparam;	char cosname[ODP_COS_NAME_LEN];	char queuename[ODP_QUEUE_NAME_LEN];	uint32_t addr = 0;	uint32_t mask;	parse_ipv4_string(CLS_PMR_SET_SADDR, &addr, &mask);	pmr_terms[0].term = ODP_PMR_SIP_ADDR;	pmr_terms[0].val = &addr;	pmr_terms[0].mask = &mask;	pmr_terms[0].val_sz = sizeof(addr);	val = CLS_PMR_SET_SPORT;	maskport = 0xffff;	pmr_terms[1].term = ODP_PMR_UDP_SPORT;	pmr_terms[1].val = &val;	pmr_terms[1].mask = &maskport;	pmr_terms[1].val_sz = sizeof(val);	retval = odp_pmr_match_set_create(num_terms, pmr_terms, &pmr_set);	CU_ASSERT(retval > 0);	sprintf(cosname, "cos_pmr_set");	cos_list[CLS_PMR_SET] = odp_cos_create(cosname);	CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID)	qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;	qparam.sched.sync = ODP_SCHED_SYNC_NONE;	qparam.sched.group = ODP_SCHED_GROUP_ALL;	sprintf(queuename, "%s", "cos_pmr_set_queue");	queue_list[CLS_PMR_SET] = odp_queue_create(queuename,							 ODP_QUEUE_TYPE_SCHED,							 &qparam);	CU_ASSERT_FATAL(queue_list[CLS_PMR_SET] != ODP_QUEUE_INVALID);	retval = odp_cos_set_queue(cos_list[CLS_PMR_SET],				   queue_list[CLS_PMR_SET]);	CU_ASSERT(retval == 0);	retval = odp_pktio_pmr_match_set_cos(pmr_set, pktio_loop,					     cos_list[CLS_PMR_SET]);	CU_ASSERT(retval == 0);}

voidsplit_test3(void){	struct nvme_namespace	ns;	struct nvme_controller	ctrlr;	struct nvme_request	*child;	void			*payload;	uint64_t		lba, cmd_lba;	uint32_t		lba_count, cmd_lba_count;	int			rc;	/*	 * Controller has max xfer of 128 KB (256 blocks).	 * Submit an I/O of 256 KB starting at LBA 10, which should be split	 * into two I/Os:	 *  1) LBA = 10, count = 256 blocks	 *  2) LBA = 266, count = 256 blocks	 */	prepare_for_test(&ns, &ctrlr, 512, 128 * 1024, 0);	payload = malloc(256 * 1024);	lba = 10; /* Start at an LBA that isn't aligned to the stripe size */	lba_count = (256 * 1024) / 512;	rc = nvme_ns_cmd_read(&ns, payload, lba, lba_count, NULL, NULL);	CU_ASSERT(rc == 0);	CU_ASSERT_FATAL(g_request != NULL);	CU_ASSERT_FATAL(g_request->num_children == 2);	child = TAILQ_FIRST(&g_request->children);	TAILQ_REMOVE(&g_request->children, child, child_tailq);	nvme_cmd_interpret_rw(&child->cmd, &cmd_lba, &cmd_lba_count);	CU_ASSERT(child->num_children == 0);	CU_ASSERT(child->payload_size == 128 * 1024);	CU_ASSERT(cmd_lba == 10);	CU_ASSERT(cmd_lba_count == 256);	child = TAILQ_FIRST(&g_request->children);	TAILQ_REMOVE(&g_request->children, child, child_tailq);	nvme_cmd_interpret_rw(&child->cmd, &cmd_lba, &cmd_lba_count);	CU_ASSERT(child->num_children == 0);	CU_ASSERT(child->payload_size == 128 * 1024);	CU_ASSERT(cmd_lba == 266);	CU_ASSERT(cmd_lba_count == 256);	CU_ASSERT(TAILQ_EMPTY(&g_request->children));	free(payload);	nvme_free_request(g_request);}

void scheduler_test_wait_time(void){	odp_queue_t queue;	uint64_t wait_time;	odp_queue_param_t qp;	odp_time_t lower_limit, upper_limit;	odp_time_t start_time, end_time, diff;	/* check on read */	wait_time = odp_schedule_wait_time(0);	wait_time = odp_schedule_wait_time(1);	(void)wait_time;	/* check ODP_SCHED_NO_WAIT */	odp_queue_param_init(&qp);	queue = odp_queue_create("dummy_queue", ODP_QUEUE_TYPE_SCHED, &qp);	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);	wait_time = odp_schedule_wait_time(ODP_TIME_SEC_IN_NS);	start_time = odp_time_local();	odp_schedule(&queue, ODP_SCHED_NO_WAIT);	end_time = odp_time_local();	diff = odp_time_diff(end_time, start_time);	lower_limit = ODP_TIME_NULL;	upper_limit = odp_time_local_from_ns(ODP_WAIT_TOLERANCE);	CU_ASSERT(odp_time_cmp(diff, lower_limit) >= 0);	CU_ASSERT(odp_time_cmp(diff, upper_limit) <= 0);#ifndef MAGIC_SCALL	int i;	/* check time correctness */	start_time = odp_time_local();	for (i = 1; i < 6; i++) {		odp_schedule(&queue, wait_time);		/* printf("%d..", i); */	}	end_time = odp_time_local();	diff = odp_time_diff(end_time, start_time);	lower_limit = odp_time_local_from_ns(5 * ODP_TIME_SEC_IN_NS -							ODP_WAIT_TOLERANCE);	upper_limit = odp_time_local_from_ns(5 * ODP_TIME_SEC_IN_NS +							ODP_WAIT_TOLERANCE);	CU_ASSERT(odp_time_cmp(diff, lower_limit) >= 0);	CU_ASSERT(odp_time_cmp(diff, upper_limit) <= 0);#endif	CU_ASSERT_FATAL(odp_queue_destroy(queue) == 0);}

void btnNew_sanity_check(BTree *bt, BTreeNode *btn, uint8_t type){  bool leaf = (type == PGTYPE_TABLE_LEAF || type == PGTYPE_INDEX_LEAF);  btn_sanity_check(bt, btn, true);  CU_ASSERT_FATAL(btn->type == type);  CU_ASSERT_FATAL(btn->n_cells == 0);  CU_ASSERT_FATAL(btn->free_offset == 		  (leaf? LEAFPG_CELLSOFFSET_OFFSET : INTPG_CELLSOFFSET_OFFSET));  CU_ASSERT_FATAL(btn->cells_offset == bt->pager->page_size);  CU_ASSERT_FATAL(btn->celloffset_array == 		  (uint8_t*) (btn->page->data + 			      (leaf? LEAFPG_CELLSOFFSET_OFFSET : INTPG_CELLSOFFSET_OFFSET)));}

void test_class_db_object_field_list(void) {    db_object_field_t* local_object_field = object_field;    db_object_field_t* local_object_field2 = object_field2;    const db_object_field_t* object_field_walk;    CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));    CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));    object_field = NULL;    CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field2));    object_field2 = NULL;    CU_ASSERT((object_field_walk = db_object_field_list_begin(object_field_list)) == local_object_field);    CU_ASSERT(db_object_field_next(object_field_walk) == local_object_field2);}

static void schedule_common(odp_schedule_sync_t sync, int num_queues,			    int num_prio, int enable_schd_multi){	thread_args_t args;	odp_shm_t shm;	test_globals_t *globals;	shm = odp_shm_lookup(GLOBALS_SHM_NAME);	CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);	globals = odp_shm_addr(shm);	CU_ASSERT_PTR_NOT_NULL_FATAL(globals);	memset(&args, 0, sizeof(thread_args_t));	args.globals = globals;	args.sync = sync;	args.num_queues = num_queues;	args.num_prio = num_prio;	args.num_bufs = BUFS_PER_QUEUE;	args.num_workers = 1;	args.enable_schd_multi = enable_schd_multi;	args.enable_excl_atomic = 0;	/* Not needed with a single CPU */	fill_queues(&args);	schedule_common_(&args);	if (sync == ODP_SCHED_SYNC_ORDERED)		reset_queues(&args);}

voidtest_ctrlr_failed(void){	struct nvme_qpair	qpair = {};	struct nvme_request	*req;	struct nvme_controller	ctrlr = {};	struct nvme_registers	regs = {};	char			payload[4096];	prepare_submit_request_test(&qpair, &ctrlr, &regs);	req = nvme_allocate_request(payload, sizeof(payload), expected_failure_callback, NULL);	CU_ASSERT_FATAL(req != NULL);	/* Disable the queue and set the controller to failed.	 * Set the controller to resetting so that the qpair won't get re-enabled.	 */	qpair.is_enabled = false;	ctrlr.is_failed = true;	ctrlr.is_resetting = true;	outbuf[0] = '/0';	CU_ASSERT(qpair.sq_tail == 0);	nvme_qpair_submit_request(&qpair, req);	CU_ASSERT(qpair.sq_tail == 0);	/* Assert that command/completion data was printed to log. */	CU_ASSERT(strlen(outbuf) > 0);	cleanup_submit_request_test(&qpair);}

voidtest4(void){	struct nvme_qpair	qpair = {};	struct nvme_request	*req;	struct nvme_controller	ctrlr = {};	struct nvme_registers	regs = {};	char			payload[4096];	prepare_submit_request_test(&qpair, &ctrlr, &regs);	req = nvme_allocate_request(payload, sizeof(payload), expected_failure_callback, NULL);	CU_ASSERT_FATAL(req != NULL);	/* Force vtophys to return a failure.  This should	 *  result in the nvme_qpair manually failing	 *  the request with error status to signify	 *  a bad payload buffer.	 */	fail_vtophys = true;	outbuf[0] = '/0';	CU_ASSERT(qpair.sq_tail == 0);	nvme_qpair_submit_request(&qpair, req);	CU_ASSERT(qpair.sq_tail == 0);	/* Assert that command/completion data was printed to log. */	CU_ASSERT(strlen(outbuf) > 0);	cleanup_submit_request_test(&qpair);}

voidsplit_test(void){	struct nvme_namespace	ns;	struct nvme_controller	ctrlr;	void			*payload;	uint64_t		lba, cmd_lba;	uint32_t		lba_count, cmd_lba_count;	int			rc;	prepare_for_test(&ns, &ctrlr, 512, 128 * 1024, 0);	payload = malloc(512);	lba = 0;	lba_count = 1;	rc = nvme_ns_cmd_read(&ns, payload, lba, lba_count, NULL, NULL);	CU_ASSERT(rc == 0);	CU_ASSERT_FATAL(g_request != NULL);	CU_ASSERT(g_request->num_children == 0);	nvme_cmd_interpret_rw(&g_request->cmd, &cmd_lba, &cmd_lba_count);	CU_ASSERT(cmd_lba == lba);	CU_ASSERT(cmd_lba_count == lba_count);	free(payload);	nvme_free_request(g_request);}