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

/* Test MB_Iterator_CreateFiltered */void test_mb_p_iter_create_filtered(void) {        int rc;    MBIt_Board  *board;    MBIt_Iterator  *iterator;    filter_params fp;        fp.lb = TEST_FILTER_LB;    fp.ub = TEST_FILTER_UB;            /* Try invalid mboard */    mb_f = 99999999;    rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);    CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);    CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);        /* Try NULL mboard */    mb_f = MB_NULL_MBOARD;    rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);    CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);    CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);        /* Populate mboard. Abort on failure */    rc = init_mb_with_content(&mb_f);    CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);        /* Try locked board */    board = (MBIt_Board *)MBI_getMBoardRef(mb_f);    CU_ASSERT_PTR_NOT_NULL_FATAL(board);    board->locked = MB_TRUE;     rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);    CU_ASSERT_EQUAL(rc, MB_ERR_LOCKED);    CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);    board->locked = MB_FALSE;         /* Try on "unreadable" boards */    board->is_reader = MB_FALSE;    rc = MB_Iterator_Create(mb_f, &itr_f);    CU_ASSERT_EQUAL(rc, MB_ERR_DISABLED);    CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);    board->is_reader = MB_TRUE;        /* Create sorted Iterator */    itr_f = MB_NULL_ITERATOR;    rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);    CU_ASSERT_EQUAL(rc, MB_SUCCESS);    CU_ASSERT_NOT_EQUAL(itr_f, MB_NULL_ITERATOR);        board = (MBIt_Board *)MBI_getMBoardRef(mb_f);    iterator = (MBIt_Iterator *)MBI_getIteratorRef(itr_f);    CU_ASSERT_PTR_NOT_NULL_FATAL(board);    CU_ASSERT_PTR_NOT_NULL_FATAL(iterator);    CU_ASSERT_EQUAL(board->data->elem_size, iterator->msgsize);    CU_ASSERT_EQUAL(iterator->iterating, 0);    CU_ASSERT_PTR_NULL(iterator->cursor);    CU_ASSERT_EQUAL(iterator->mb, mb_f);}

void test_strpart_2(){	const char tmp[] = "x";	const char *res;	res = strpart(tmp, NULL);	CU_ASSERT_PTR_NULL(res);}

static void test_success_with_entity(void){    char* data = malloc(32);    struct result* result = 0;    sprintf(data, "some entity data");    result = success_result((void*)data, &free_data, 0, 0);    CU_ASSERT_PTR_NOT_NULL_FATAL(result);    CU_ASSERT_PTR_NULL(result->error);    CU_ASSERT_PTR_EQUAL(result->data, data);    CU_ASSERT_PTR_EQUAL(result->free_data, &free_data);    CU_ASSERT_PTR_NULL(result->location);    free_result(result);    free(data);}

void s_test_create_tree_fail(void){  int sizeOfElement = sizeof(int);  Tree tree = new_tree(sizeOfElement, NULL, NULL, NULL, NULL);  CU_ASSERT_PTR_NULL(tree);  if (tree != NULL) {    destroy_tree(&tree);   }}

static void test_string_n_split_is_empty() {	char* line = "";	char** substrings = string_n_split(line, 10, ";");	CU_ASSERT_PTR_NOT_NULL(substrings);	CU_ASSERT_PTR_NULL(substrings[0]);	free(substrings);}

voidtest_pop_stack_empty() {	stack *stack = stackCreate();	int *poppedValue = (int*)stackPop(stack);	CU_ASSERT_EQUAL(stack -> size, 0);	CU_ASSERT_PTR_NULL(poppedValue);}

voidtest_peek_stack_empty() {	stack *stack = stackCreate();	int *position1 = stackPeek(stack);		CU_ASSERT_EQUAL(stack -> size, 0);	CU_ASSERT_PTR_NULL(position1);}

/* test test_tt_getcount_col() */void test_tt_getcount_col(void) {        int i, j, rc;    int count = 999;    int rows = 10;    int cols = rows * 8;    tag_table *tt = NULL;    char octet1 = (char)0x00;    char octet2 = (char)0xff;        /* create the tt object */    rc = tt_create(&tt, rows, cols);    CU_ASSERT_EQUAL_FATAL(rc, TT_SUCCESS);    CU_ASSERT_PTR_NOT_NULL_FATAL(tt);        /* check count for newly created table */    for (i = 0; i < cols; i++)    {        rc = tt_getcount_col(tt, i, &count);        if (rc != TT_SUCCESS) CU_FAIL("tt_getcount() returned with an error");        if (count != 0) CU_FAIL("count != 0");    }        /* systematically set various bits within the table */    for (i = 0; i < rows; i++)    {        for (j = 0; j < (int)tt->row_size; j++)        {            if (i % 2 == 0)            {                rc = tt_setbyte(tt, i, j, octet1);                if (rc != TT_SUCCESS) CU_FAIL("tt_setbits() returned an error code");            }            else            {                rc = tt_setbyte(tt, i, j, octet2);                if (rc != TT_SUCCESS) CU_FAIL("tt_setbits() returned an error code");            }        }            }        /* recheck count for table */    for (i = 0; i < cols; i++)    {        rc = tt_getcount_col(tt, i, &count);        if (rc != TT_SUCCESS) CU_FAIL("tt_getcount() returned with an error");                if (count != (rows / 2)) CU_FAIL("count != rows/2");    }        /* destroy tt object */    rc = tt_delete(&tt);    CU_ASSERT_EQUAL(rc, TT_SUCCESS);    CU_ASSERT_PTR_NULL(tt);}

void test_strpart_1(){	const char tmp[] = "x";	const char *res;	res = strpart(NULL, tmp);	CU_ASSERT_PTR_NULL(res);}

/* we expect _getnode() to have been tested before this test is called */void test_avl_insert_withptr(void) {    int i, errcount;    int *data;    int testvals[TEST_AVL_TREESIZE];    MBIt_AVLtree *tree = NULL;    MBIt_AVLnode *node = NULL;        /* create tree */    tree = MBI_AVLtree_create();    CU_ASSERT_PTR_NOT_NULL_FATAL(tree);    CU_ASSERT_EQUAL(tree->count, 0);    CU_ASSERT_PTR_NULL(tree->root);        /* it shouldn't matter if we do get duplicate values in the tree */    for (i = 0; i < TEST_AVL_TREESIZE; i++)     {         testvals[i] = i * 10; /* remember values used */                MBI_AVLtree_insert(tree, i, &testvals[i]);    }    /* use getnode to retrieve node pointer and inspect key value */    errcount = 0;    for (i = 0; i < TEST_AVL_TREESIZE; i++)     {         node = MBI_AVLtree_getnode(tree, i);        if (node == NULL)        {            errcount += 1;            continue;        }                if (node->key != i) errcount += 1;        if (node->data == NULL) {errcount += 1; continue;}        data = (int*)node->data;        if (*data != (i * 10)) errcount += 1;    }    CU_ASSERT_EQUAL(errcount, 0);            /* destroy tree */    MBI_AVLtree_destroy(&tree);    CU_ASSERT_PTR_NULL(tree);}

void simple_log_test(void){    struct commit* commit_list = NULL;    int retval;    retval = beargit_init();    CU_ASSERT(0==retval);    FILE* asdf = fopen("asdf.txt", "w");    fclose(asdf);    retval = beargit_add("asdf.txt");    CU_ASSERT(0==retval);    run_commit(&commit_list, "GO BEARS!1");    run_commit(&commit_list, "GO BEARS!2");    run_commit(&commit_list, "GO BEARS!3");    retval = beargit_log(INT_MAX);    CU_ASSERT(0==retval);    struct commit* cur_commit = commit_list;    const int LINE_SIZE = 512;    char line[LINE_SIZE];    FILE* fstdout = fopen("TEST_STDOUT", "r");    CU_ASSERT_PTR_NOT_NULL(fstdout);    while (cur_commit != NULL) {      char refline[LINE_SIZE];      // First line is empty      CU_ASSERT_PTR_NOT_NULL(fgets(line, LINE_SIZE, fstdout));      CU_ASSERT(!strcmp(line,"/n"));      // Second line is commit -- don't check the ID.      CU_ASSERT_PTR_NOT_NULL(fgets(line, LINE_SIZE, fstdout));      CU_ASSERT(!strncmp(line,"commit", strlen("commit")));      // Third line is msg      sprintf(refline, "    %s/n", cur_commit->msg);      CU_ASSERT_PTR_NOT_NULL(fgets(line, LINE_SIZE, fstdout));      CU_ASSERT_STRING_EQUAL(line, refline);      cur_commit = cur_commit->next;    }    // Last line is empty    CU_ASSERT_PTR_NOT_NULL(fgets(line, LINE_SIZE, fstdout));    CU_ASSERT(!strcmp(line,"/n"));    CU_ASSERT_PTR_NULL(fgets(line, LINE_SIZE, fstdout));    // It's the end of output    CU_ASSERT(feof(fstdout));    fclose(fstdout);    free_commit_list(&commit_list);}

void test_strpart_5(){	const char tmp1[] = "abcdefg";	const char tmp2[] = "abc";	const char *res;	res = strpart(tmp1, tmp2);	CU_ASSERT_PTR_NULL(res);}

void test_Destory(void) {	Status status = ERROR;	GENERALIZED_LIST_TYPE list = getGeneralizedList("(1,2,3,4)");	if (list == NULL)		return;	status = Destory(&list);	CU_ASSERT_EQUAL(status, OK);	CU_ASSERT_PTR_NULL(list);}

void test_avl_memberof(void) {        int i, errcount, v;    int testvals[TEST_AVL_TREESIZE];    MBIt_AVLtree *tree = NULL;        tree = MBI_AVLtree_create();    CU_ASSERT_PTR_NOT_NULL_FATAL(tree);    CU_ASSERT_EQUAL(tree->count, 0);    CU_ASSERT_PTR_NULL(tree->root);        /* get list of unique random ints */    generate_random_unique_ints(testvals, TEST_AVL_TREESIZE);        /* add nodes */    for (i = 0; i < TEST_AVL_TREESIZE; i++)    {        MBI_AVLtree_insert(tree, testvals[i], NULL);    }        check_tree_integrity(tree);        /* try checking with 2 * TEST_AVL_TREESIZE random values */    errcount = 0;    for (i = 0; i < TEST_AVL_TREESIZE * 2; i++)    {        v = rand();        if (_in_array(testvals, TEST_AVL_TREESIZE, v) !=             MBI_AVLtree_memberof(tree, v))  errcount++;    }    CU_ASSERT_EQUAL(errcount, 0);        /* check againts all actual values */    for (i = 0; i < TEST_AVL_TREESIZE; i++)    {        v = testvals[i];        if (! MBI_AVLtree_memberof(tree, v)) errcount++;    }    CU_ASSERT_EQUAL(errcount, 0);        MBI_AVLtree_destroy(&tree);    CU_ASSERT_PTR_NULL(tree);}

static void test_string_n_split_when_separator_isnt_included() {	char *line = "Hola planeta tierra";	char ** substrings = string_n_split(line, 5, ";");	CU_ASSERT_PTR_NOT_NULL(substrings);	CU_ASSERT_STRING_EQUAL(substrings[0], line);	CU_ASSERT_PTR_NULL(substrings[1]);	string_iterate_lines(substrings, (void *) free);	free(substrings);}

void ms_tester_create_filters(unsigned int filter_mask) {	MSSndCardManager *manager;	MSSndCard *playcard;	MSSndCard *captcard;	CREATE_FILTER(FILTER_MASK_FILEPLAY, ms_tester_fileplay, MS_FILE_PLAYER_ID);	CREATE_FILTER(FILTER_MASK_FILEREC, ms_tester_filerec, MS_FILE_REC_ID);	CREATE_FILTER(FILTER_MASK_DTMFGEN, ms_tester_dtmfgen, MS_DTMF_GEN_ID);	CREATE_FILTER(FILTER_MASK_TONEDET, ms_tester_tonedet, MS_TONE_DETECTOR_ID);	CREATE_FILTER(FILTER_MASK_VOIDSOURCE, ms_tester_voidsource, MS_VOID_SOURCE_ID);	CREATE_FILTER(FILTER_MASK_VOIDSINK, ms_tester_voidsink, MS_VOID_SINK_ID);	if (filter_mask & FILTER_MASK_ENCODER) {		CU_ASSERT_PTR_NULL(ms_tester_encoder);		ms_tester_encoder = ms_filter_create_encoder(ms_tester_codec_mime);		CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_encoder);	}	if (filter_mask & FILTER_MASK_DECODER) {		CU_ASSERT_PTR_NULL(ms_tester_decoder);		ms_tester_decoder = ms_filter_create_decoder(ms_tester_codec_mime);		CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_decoder);	}	CREATE_FILTER(FILTER_MASK_RTPRECV, ms_tester_rtprecv, MS_RTP_RECV_ID);	CREATE_FILTER(FILTER_MASK_RTPSEND, ms_tester_rtpsend, MS_RTP_SEND_ID);	CREATE_FILTER(FILTER_MASK_RESAMPLER, ms_tester_resampler, MS_RESAMPLE_ID);	if (filter_mask & FILTER_MASK_SOUNDWRITE) {		CU_ASSERT_PTR_NULL(ms_tester_soundwrite);		manager = ms_snd_card_manager_get();		playcard = ms_snd_card_manager_get_default_playback_card(manager);		CU_ASSERT_PTR_NOT_NULL_FATAL(playcard);		ms_tester_soundwrite = ms_snd_card_create_writer(playcard);		CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundwrite);	}	if (filter_mask & FILTER_MASK_SOUNDREAD) {		CU_ASSERT_PTR_NULL(ms_tester_soundread);		manager = ms_snd_card_manager_get();		captcard = ms_snd_card_manager_get_default_capture_card(manager);		CU_ASSERT_PTR_NOT_NULL_FATAL(captcard);		ms_tester_soundread = ms_snd_card_create_reader(captcard);		CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundread);	}}

static void test_string_n_split_when_n_is_less_than_splitted_elements() {	char *line = "Hola planeta tierra";	char** substrings = string_n_split(line, 2, " ");	CU_ASSERT_PTR_NOT_NULL(substrings);	CU_ASSERT_STRING_EQUAL(substrings[0], "Hola");	CU_ASSERT_STRING_EQUAL(substrings[1], "planeta tierra");	CU_ASSERT_PTR_NULL(substrings[2]);	string_iterate_lines(substrings, (void*) free);	free(substrings);}

void test_get_tail    (    void    ){uint32_t arr[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};uint32_t i;list * new_list = make_new_list();node * cur = get_tail(new_list);CU_ASSERT_PTR_NOT_NULL(new_list);CU_ASSERT_PTR_NULL(cur);for(i = 0; i < 10; i++)    {    add(new_list, &(arr[i]));    }cur = get_tail(new_list);CU_ASSERT_PTR_NOT_NULL(cur);CU_ASSERT_EQUAL(*(uint32_t *)cur->data, arr[9]);CU_ASSERT_PTR_NULL(cur->next);CU_ASSERT_PTR_NOT_NULL(cur->prev);}

/** * init_lsit原型:  *      bool init_list(seq_list *s_list, const int element_size) * * init_list函数检查说明: *      1. element_size的有效值是正整数. *      2. 当element_size输入无效参数时, 返回值为NULL. */ static void test_init_list(void) {        int element_size = 0;        /* case 1: element_size = 0 */        element_size = 0;        ps_list = init_list(element_size);        CU_ASSERT_PTR_NULL(ps_list);        /* case 2: element_size < 0 */         element_size = -1;        ps_list = init_list(element_size);        CU_ASSERT_PTR_NULL(ps_list);        /* case 3: element_size > 0 */        element_size = 1;        ps_list = init_list(element_size);        CU_ASSERT_PTR_NOT_NULL(ps_list);        CU_ASSERT_EQUAL(ps_list->element_size, element_size);        CU_ASSERT_EQUAL(ps_list->length, 0);}

void test_find_opcode_new(void) {    CSOUND* csound = csoundCreate(NULL);    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, "##error", "i", "i"));    CU_ASSERT_PTR_NULL(find_opcode_new(csound, "##error", NULL, "i"));    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, "##xin64", "i", NULL));    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, "##xin256", "i", NULL));    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, "##userOpcode", NULL, NULL));    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, "##array_set", NULL, "k[]k"));    CU_ASSERT_PTR_NOT_NULL(find_opcode_new(csound, ">=", "B", "kc"));    }

/** * La fonction 'tutu' n'existe pas ,donc renvoie NULL */void test_fonction_tutu_biblio(){    void *bibliotheque;    int (*fonction_tutu)(int);    bibliotheque=dlopen("./biblio.so",RTLD_NOW);    CU_ASSERT_PTR_NOT_NULL(bibliotheque);    fonction_tutu=dlsym(bibliotheque,"tutu");    CU_ASSERT_PTR_NULL(fonction_tutu);        dlclose(bibliotheque);}

void test_llist_add(void) {  Llist list = NULL;  Node node;  node_alloc(&node);  node.score = 150;  mpz_set_str(*(node.data), "1234", 10);  /* list should be NULL */  CU_ASSERT_PTR_NULL(list);  /* Add the node to the list */  llist_add(node, &list);  /* Look if the data contained in the list are the same than the node added */  CU_ASSERT_TRUE(node_is_equal(list->value, node));  /* int i = 1; */  /* Element *tmp = list; */  /* while (tmp != NULL) { */  /*   printf("#n = %d/n", i++); */  /*   node_print(tmp->value); */  /*   tmp = tmp->next; */  /* } */  /* Add a new node */  node.score++;  mpz_set_str(*(node.data), "5678", 10);  llist_add(node, &list);  /* Look if the node has been added BEFORE the first one     (because his score is higher) */  CU_ASSERT_TRUE(node_is_equal(list->value, node));  /* Add another node */  node.score -= 2;  llist_add(node, &list);  /* Look if the node at the top has not changed     (because his score is lower) */  node.score += 2;  CU_ASSERT_TRUE(node_is_equal(list->value, node));  /* i = 0; */  /* tmp = list; */  /* while (tmp != NULL) { */  /*   printf("#n = %d/n", i++); */  /*   node_print(tmp->value); */  /*   tmp = tmp->next; */  /* } */  llist_free(&list);  node_free(&node);}

static voidnvmf_test_find_subsystem(void){	struct spdk_nvmf_subsystem *subsystem;	//char long_name[MAX_NQN_SIZE];	CU_ASSERT_PTR_NULL(nvmf_find_subsystem(NULL));	subsystem = nvmf_find_subsystem("subsystem1");	CU_ASSERT_EQUAL(subsystem->num, 1);	CU_ASSERT_STRING_EQUAL(subsystem->subnqn, "subsystem1");	/* check long name */	/* segment fault. Comment it */	/*	memset(long_name, 'a', MAX_NQN_SIZE);	subsystem = nvmf_find_subsystem(long_name);	CU_ASSERT_EQUAL(subsystem->num, 2);	CU_ASSERT_STRING_EQUAL(subsystem->subnqn, long_name);	*/	/* check none-exist subsystem */	CU_ASSERT_PTR_NULL(nvmf_find_subsystem("fake"));}

void assertIntArrayEqual(int* a, int* b) {	if (a == NULL) {		CU_ASSERT_PTR_NULL(b);		return;	}	if (b == NULL) {		CU_ASSERT_PTR_NULL(a);		return;	}	int length_a = a[0];	int length_b = b[0];	CU_ASSERT_EQUAL(length_a, length_b);	if (length_a != length_b)		return;	int i = 0;	for (i = 1; i <= length_a; i++) {		CU_ASSERT_EQUAL(a[i], b[i]);	}}

static void test_group(void){    struct address *a;    a = NULL;    parseaddr_list("Buddies: Fred Bloggs <[email
C++ CU_ASSERT_STRING_EQUAL函数代码示例
C++ CU_ASSERT_PTR_NOT_NULL_FATAL函数代码示例