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

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");}

voidtest_reserve6_target_warm_reset(void){	int ret;	struct scsi_device sd2;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test that RESERVE6 is released on target warm reset");	if (sd->iscsi_ctx == NULL) {		const char *err = "[SKIPPED] This RESERVE6 test is only "			"supported for iSCSI backends";		logging(LOG_NORMAL, "%s", err);		CU_PASS(err);		return;	}	logging(LOG_VERBOSE, "Take out a RESERVE6 from the first initiator");	ret = reserve6(sd);	if (ret == -2) {		logging(LOG_VERBOSE, "[SKIPPED] Target does not support RESERVE6. Skipping test");		CU_PASS("[SKIPPED] Target does not support RESERVE6. Skipping test");		return;	}	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Send a Warm Reset to the target");	ret = iscsi_task_mgmt_target_warm_reset_sync(sd->iscsi_ctx);	if (ret != 0) {		logging(LOG_NORMAL, "Warm reset failed. %s", iscsi_get_error(sd->iscsi_ctx));	}	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Sleep for three seconds incase the target is slow to reset");	sleep(3);	logging(LOG_VERBOSE, "Create a second connection to the target");	memset(&sd2, 0, sizeof(sd2));	sd2.iscsi_url = sd->iscsi_url;	sd2.iscsi_lun = sd->iscsi_lun;	sd2.iscsi_ctx = iscsi_context_login(initiatorname2, sd2.iscsi_url, &sd2.iscsi_lun);	if (sd2.iscsi_ctx == NULL) {		logging(LOG_VERBOSE, "Failed to login to target");		return;	}	logging(LOG_VERBOSE, "RESERVE6 from the second initiator should work now");	ret = reserve6(&sd2);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "RELEASE6 from the second initiator");	ret = release6(&sd2);	CU_ASSERT_EQUAL(ret, 0);	iscsi_logout_sync(sd2.iscsi_ctx);	iscsi_destroy_context(sd2.iscsi_ctx);}

void * fonction_thread (){    cpt=100;       while (cpt--) {            le_sem_Wait(GSemPtr);            fprintf(stdout, "/n%d : thread '%s' has %s %d/n",                    cpt,le_thread_GetMyName(),SEM_NAME_1,le_sem_GetValue(GSemPtr));            CU_PASS("thread GSemPtr get");            le_sem_Wait(GSem2Ptr);            fprintf(stdout, "/n%d : thread '%s' has %s %d/n",                    cpt,le_thread_GetMyName(),SEM_NAME_2,le_sem_GetValue(GSem2Ptr));            CU_PASS("thread GSem2Ptr get");            usleep(10000);            le_sem_Post(GSem2Ptr);            fprintf(stdout, "/n%d : thread '%s' release %s %d/n",                    cpt,le_thread_GetMyName(),SEM_NAME_2,le_sem_GetValue(GSem2Ptr));            CU_PASS("thread GSemPtr2 UnLocked");            le_sem_Post(GSemPtr);            fprintf(stdout, "/n%d : thread '%s' release %s %d/n",                    cpt,le_thread_GetMyName(),SEM_NAME_1,le_sem_GetValue(GSemPtr));            CU_PASS("thread GSemPtr UnLocked");    }    return NULL;}

voidtest_reserve6_logout(void){	int ret;	struct scsi_device *sd2;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test that RESERVE6 is released on logout");	if (sd->iscsi_ctx == NULL) {		const char *err = "[SKIPPED] This RESERVE6 test is only "			"supported for iSCSI backends";		logging(LOG_NORMAL, "%s", err);		CU_PASS(err);		return;	}	logging(LOG_NORMAL, "Take out a RESERVE6 from the first initiator");	ret = reserve6(sd);	if (ret == -2) {		logging(LOG_VERBOSE, "[SKIPPED] Target does not support RESERVE6. Skipping test");		CU_PASS("[SKIPPED] Target does not support RESERVE6. Skipping test");		return;	}	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Create a second connection to the target");	ret = mpath_sd2_get_or_clone(sd, &sd2);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_NORMAL, "Try to take out a RESERVE6 from the second initiator");	ret = reserve6_conflict(sd2);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Logout from target");	iscsi_logout_sync(sd->iscsi_ctx);	iscsi_destroy_context(sd->iscsi_ctx);	logging(LOG_VERBOSE, "Relogin to target");	sd->iscsi_ctx = iscsi_context_login(initiatorname1, sd->iscsi_url, &sd->iscsi_lun);	if (sd->iscsi_ctx == NULL) {		logging(LOG_VERBOSE, "Failed to login to target");		return;	}	logging(LOG_NORMAL, "RESERVE6 from the second initiator should work now");	ret = reserve6(sd2);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_NORMAL, "RELEASE6 from the second initiator");	ret = release6(sd2);	CU_ASSERT_EQUAL(ret, 0);	mpath_sd2_put(sd2);}

voidtest_read6_simple(void){	int i, ret;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test READ6 of 1-255 blocks at the start of the LUN");	for (i = 1; i <= 255; i++) {		ret = read6(iscsic, tgt_lun, 0, i * block_size,			    block_size, NULL);		if (ret == -2) {			logging(LOG_NORMAL, "[SKIPPED] READ6 is not implemented.");			CU_PASS("READ6 is not implemented.");			return;		}			CU_ASSERT_EQUAL(ret, 0);	}	logging(LOG_VERBOSE, "Test READ6 of 1-255 blocks at the end of the LUN");	if (num_blocks > 0x200000) {		CU_PASS("LUN is too big for read-at-eol tests with READ6. Skipping test./n");	} else {		for (i = 1; i <= 255; i++) {			ret = read6(iscsic, tgt_lun, num_blocks - i,				i * block_size, block_size, NULL);			CU_ASSERT_EQUAL(ret, 0);		}	}	logging(LOG_VERBOSE, "Transfer length == 0 means we want to transfer "		"256 blocks");	logging(LOG_VERBOSE, "Test sending a READ6 with transfer length == 0 "		"(meaning 256 blocks)");	/* 256 is converted to 0 when the CDB is marshalled by the helper */	task = iscsi_read6_sync(iscsic, tgt_lun, 0,				256 * block_size, block_size);	if (task->status != SCSI_STATUS_GOOD) {		logging(LOG_NORMAL, "[FAILED] READ6 command: "			"failed with sense. %s", iscsi_get_error(iscsic));	}	CU_ASSERT_EQUAL(task->status, SCSI_STATUS_GOOD);	logging(LOG_VERBOSE, "Verify that we did get 256 blocks of data back");	if (task->datain.size == (int)(256 * block_size)) {		logging(LOG_VERBOSE, "[SUCCESS] Target returned 256 blocks of "			"data");	} else {		logging(LOG_NORMAL, "[FAILED] Target did not return 256 "			"blocks of data");	}	CU_ASSERT_EQUAL(task->datain.size, (int)(256 * block_size));}

voidtest_writeatomic16_wrprotect(void){    int i, gran, ret;    unsigned char *buf = alloca(block_size);    CHECK_FOR_DATALOSS;    CHECK_FOR_SBC;    if (!inq_bl) {        CU_PASS("BlockLimits VPD is not available. Skipping test./n");        return;    }    logging(LOG_VERBOSE, LOG_BLANK_LINE);    gran = inq_bl->atomic_gran ? inq_bl->atomic_gran : 1;    ret = writeatomic16(sd, 0,                        block_size * gran,                        block_size, 0, 0, 0, 0, buf,                        EXPECT_STATUS_GOOD);    if (ret == -2) {        logging(LOG_NORMAL, "[SKIPPED] WRITEATOMIC16 is not implemented.");        CU_PASS("WRITEATOMIC16 is not implemented.");        return;    }    CU_ASSERT_EQUAL(ret, 0);    logging(LOG_VERBOSE, "Test WRITEATOMIC16 with non-zero WRPROTECT");    memset(buf, 0xa6, block_size);    if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {        logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");        for (i = 1; i < 8; i++) {            ret = writeatomic16(sd, 0,                                gran * block_size, block_size,                                i, 0, 0, 0, buf,                                EXPECT_INVALID_FIELD_IN_CDB);            if (ret == -2) {                logging(LOG_NORMAL, "[SKIPPED] WRITEATOMIC16 is not implemented.");                CU_PASS("WRITEATOMIC16 is not implemented.");                return;            }            CU_ASSERT_EQUAL(ret, 0);        }        return;    }    logging(LOG_NORMAL, "No tests for devices that support protection information yet.");}

voidtest_writesame16_0blocks(void){	int ret;	CHECK_FOR_DATALOSS;	CHECK_FOR_SBC;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==0 (WSNZ=%d)",		inq_bl->wsnz);	ret = writesame16(iscsic, tgt_lun, 0,			  block_size, 0,			  0, 0, 0, 0, NULL);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");		CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");		return;	} else if (ret == -3) {		CU_PASS("[SKIPPED] Target does not support WRITESAME16 with NUMBER OF LOGICAL BLOCKS == 0");	} else if (ret == -4) {		CU_PASS("[SKIPPED] Number of WRITESAME16 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");	} else {		if (inq_bl->wsnz) {			CU_ASSERT_EQUAL(ret, -1);		} else {			CU_ASSERT_EQUAL(ret, 0);		}	}	logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks one block past end-of-LUN");	ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1,					block_size, inq_bl->wsnz,					0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==2^63");	ret = writesame16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL,					block_size, inq_bl->wsnz,					0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==-1");	ret = writesame16_lbaoutofrange(iscsic, tgt_lun, -1,					block_size, inq_bl->wsnz,					0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);}

void testCreateDestroy(void){    le_sem_Ref_t semPtr=NULL,semPtr2=NULL;    semPtr     = le_sem_Create( "SEMAPHORE-1", 10);    CU_ASSERT_PTR_NOT_EQUAL(semPtr, NULL);    semPtr2    = le_sem_CreateTraceable( "SEMAPHORE-2", 1);    CU_ASSERT_PTR_NOT_EQUAL(semPtr2, NULL);    le_sem_Delete(semPtr);    CU_PASS("Destruct semaphore/n");    le_sem_Delete(semPtr2);    CU_PASS("Destruct semaphore/n");}

voidtest_prin_read_keys_simple(void){	int ret = 0;	int al;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test Persistent Reserve IN READ_KEYS works.");	ret = prin_read_keys(iscsic, tgt_lun, &task, NULL);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] PERSISTEN RESERVE IN is not implemented.");		CU_PASS("PERSISTENT RESERVE IN is not implemented.");		return;	}		CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test DATA-IN is at least 8 bytes.");	if (task->datain.size < 8) {		logging(LOG_NORMAL,		    "[FAILED] DATA-IN returned less than 8 bytes");		return;	}	logging(LOG_VERBOSE, "Test ADDITIONAL_LENGTH matches DATA_IN size.");	al = scsi_get_uint32(&task->datain.data[4]);	if (al != task->datain.size - 8) {		logging(LOG_NORMAL,		    "[FAILED] ADDITIONAL_LENGTH was %d bytes but %d was expected.",			al, task->datain.size - 8);		return;	}}

voidtest_verify12_flags(void){	int ret;	unsigned char *buf = alloca(block_size);	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test VERIFY12 flags");	ret = read10(iscsic, tgt_lun, 0, block_size,		     block_size, 0, 0, 0, 0, 0, buf);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test VERIFY12 with DPO==1");	ret = verify12(iscsic, tgt_lun, 0, block_size,		       block_size, 0, 1, 0, buf);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");		CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");		return;	}	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test VERIFY12 with BYTCHK==1");	ret = verify12(iscsic, tgt_lun, 0, block_size,		       block_size, 0, 0, 1, buf);	CU_ASSERT_EQUAL(ret, 0);}

voidtest_sanitize_exit_failure_mode(void){         struct iscsi_data data;        struct scsi_command_descriptor *cd;        logging(LOG_VERBOSE, LOG_BLANK_LINE);        logging(LOG_VERBOSE, "Test SANITIZE EXIT FAILURE MODE");        CHECK_FOR_SANITIZE;        CHECK_FOR_DATALOSS;        logging(LOG_VERBOSE, "Check that SANITIZE EXIT FAILURE MODE is "                "supported in REPORT_SUPPORTED_OPCODES");        cd = get_command_descriptor(SCSI_OPCODE_SANITIZE,                                    SCSI_SANITIZE_EXIT_FAILURE_MODE);        if (cd == NULL) {                logging(LOG_NORMAL, "[SKIPPED] SANITIZE EXIT FAILURE MODE is "                        "not implemented according to "                        "REPORT_SUPPORTED_OPCODES.");                CU_PASS("SANITIZE is not implemented.");                return;        }        data.size = 8;        data.data = alloca(data.size);        memset(data.data, 0, data.size);        logging(LOG_VERBOSE, "EXIT_FAILURE_MODE parameter list length must "                "be 0");        logging(LOG_VERBOSE, "Test that non-zero param length is an error for "                "EXIT_FAILURE_MODE");        SANITIZE(sd, 0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data,                 EXPECT_INVALID_FIELD_IN_CDB);}

static voidtest_ofp_packet_input_local_UDPv4_hook(void){    odp_packet_t pkt;    int res;    /* Call ofp_packet_input with a pkt with destination ip     * that matches the local ip on ifnet.     * The packet is terminated in local UDPv4 hook */    my_test_val = TEST_LOCAL_UDPv4_HOOK;    ifnet->ip_addr = dst_ipaddr;    if (create_odp_packet_ip4(&pkt, test_frame, sizeof(test_frame),                              dst_ipaddr, 0)) {        CU_FAIL("Fail to create packet");        return;    }    res = ofp_packet_input(pkt, interface_queue[port],                           ofp_eth_vlan_processing);    CU_ASSERT_EQUAL(res, OFP_TEST_LOCAL_UDPv4_HOOK);#ifdef SP    CU_ASSERT_EQUAL(odp_queue_deq(ifnet->spq_def), ODP_EVENT_INVALID);#endif /* SP */    CU_ASSERT_EQUAL(odp_queue_deq(ifnet->outq_def), ODP_EVENT_INVALID);    ifnet->ip_addr = 0;    CU_PASS("ofp_packet_input_local_UDPv4_hook");}

voidtest_read10_0blocks(void){	int ret;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test READ10 0-blocks at LBA==0");	ret = read10(iscsic, tgt_lun, 0, 0, block_size,		     0, 0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);	if (num_blocks > 0x80000000) {		CU_PASS("[SKIPPED] LUN is too big");		return;	}	logging(LOG_VERBOSE, "Test READ10 0-blocks one block past end-of-LUN");	ret = read10_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1, 0,				   block_size, 0, 0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test READ10 0-blocks at LBA==2^31");	ret = read10_lbaoutofrange(iscsic, tgt_lun, 0x80000000, 0, block_size,				   0, 0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test READ10 0-blocks at LBA==-1");	ret = read10_lbaoutofrange(iscsic, tgt_lun, -1, 0, block_size,				   0, 0, 0, 0, 0, NULL);	CU_ASSERT_EQUAL(ret, 0);}

voidtest_verify16_vrprotect(void){	int i, ret;	unsigned char *buf = alloca(block_size);	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test VERIFY16 with non-zero VRPROTECT");	CHECK_FOR_SBC;	if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {		logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");		for (i = 1; i < 8; i++) {			ret = read16(iscsic, tgt_lun, 0, block_size,			    block_size, 0, 0, 0, 0, 0, buf);				ret = verify16_invalidfieldincdb(iscsic, tgt_lun, 0, block_size,							 block_size, i, 0, 1, buf);			if (ret == -2) {				logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");				CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");				return;			}			CU_ASSERT_EQUAL(ret, 0);		}		return;	}	logging(LOG_NORMAL, "No tests for devices that support protection information yet.");}

voidtest_orwrite_wrprotect(void){	int i, ret;	unsigned char *buf = alloca(block_size);	/*	 * Try out different non-zero values for WRPROTECT.	 */	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test ORWRITE with non-zero WRPROTECT");	CHECK_FOR_DATALOSS;	CHECK_FOR_SBC;	if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {		logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");		for (i = 1; i < 8; i++) {			ret = orwrite_invalidfieldincdb(iscsic, tgt_lun, 0,					       block_size, block_size,					       i, 0, 0, 0, 0, buf);			if (ret == -2) {				logging(LOG_NORMAL, "[SKIPPED] ORWRITE is not implemented.");				CU_PASS("ORWRITE is not implemented.");				return;			}				CU_ASSERT_EQUAL(ret, 0);		}		return;	}	logging(LOG_NORMAL, "No tests for devices that support protection information yet.");}

voidtest_writeverify12_0blocks(void){        CHECK_FOR_DATALOSS;        if (num_blocks >= 0x80000000) {                CU_PASS("LUN is too big for read-beyond-eol tests with WRITEVERIFY12. Skipping test./n");                return;        }        logging(LOG_VERBOSE, LOG_BLANK_LINE);        logging(LOG_VERBOSE, "Test WRITEVERIFY12 0-blocks at LBA==0");        WRITEVERIFY12(sd, 0, 0, block_size, 0, 0, 0, 0, NULL,                      EXPECT_STATUS_GOOD);        logging(LOG_VERBOSE, "Test WRITEVERIFY12 0-blocks one block past end-of-LUN");        WRITEVERIFY12(sd, num_blocks + 1, 0, block_size, 0, 0, 0, 0, NULL,                      EXPECT_LBA_OOB);        logging(LOG_VERBOSE, "Test WRITEVERIFY12 0-blocks at LBA==2^31");        WRITEVERIFY12(sd, 0x80000000, 0, block_size, 0, 0, 0, 0, NULL,                      EXPECT_LBA_OOB);        logging(LOG_VERBOSE, "Test WRITEVERIFY12 0-blocks at LBA==-1");        WRITEVERIFY12(sd, -1, 0, block_size, 0, 0, 0, 0, NULL,                      EXPECT_LBA_OOB);}

voidtest_read12_simple(void){	int i, ret;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test READ12 of 1-256 blocks at the start of the LUN");	for (i = 1; i <= 256; i++) {		if (maximum_transfer_length && maximum_transfer_length < i) {			break;		}		ret = read12(sd, NULL, 0, i * block_size,			     block_size, 0, 0, 0, 0, 0, NULL,			     EXPECT_STATUS_GOOD);		if (ret == -2) {			logging(LOG_NORMAL, "[SKIPPED] READ12 is not implemented.");			CU_PASS("READ12 is not implemented.");			return;		}			CU_ASSERT_EQUAL(ret, 0);	}	logging(LOG_VERBOSE, "Test READ12 of 1-256 blocks at the end of the LUN");	for (i = 1; i <= 256; i++) {		if (maximum_transfer_length && maximum_transfer_length < i) {			break;		}		ret = read12(sd, NULL, num_blocks - i,			     i * block_size, block_size, 0, 0, 0, 0, 0, NULL,			     EXPECT_STATUS_GOOD);		CU_ASSERT_EQUAL(ret, 0);	}}

voidtest_prefetch16_simple(void){	int i, ret;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test PREFETCH16 of 1-256 blocks at the start of the LUN");	for (i = 1; i <= 256; i++) {		ret = prefetch16(sd, 0, i, 0, 0,				 EXPECT_STATUS_GOOD);		if (ret == -2) {			logging(LOG_NORMAL, "[SKIPPED] PREFETCH16 is not implemented.");			CU_PASS("PREFETCH16 is not implemented.");			return;		}			CU_ASSERT_EQUAL(ret, 0);	}	logging(LOG_VERBOSE, "Test PREFETCH16 of 1-256 blocks at the end of the LUN");	for (i = 1; i <= 256; i++) {		ret = prefetch16(sd, num_blocks - i, i, 0, 0,				 EXPECT_STATUS_GOOD);		CU_ASSERT_EQUAL(ret, 0);	}}

static voidtest_ofp_packet_input_to_sp(void){    odp_packet_t pkt;    odp_event_t ev;    int res;    my_test_val = TEST_FORWARD_HOOK;    /* Call ofp_packet_input using a pkt with destination ip     * that does NOT match the local ip on ifnet and NO route is found.     * The packet is forwarded to slow path queue. */    if (create_odp_packet_ip4(&pkt, test_frame, sizeof(test_frame), 0, 0)) {        CU_FAIL("Fail to create packet");        return;    }    res = ofp_packet_input(pkt, interface_queue[port],                           ofp_eth_vlan_processing);    CU_ASSERT_EQUAL(res, OFP_PKT_PROCESSED);    CU_ASSERT_NOT_EQUAL(ev = odp_queue_deq(ifnet->spq_def),                        ODP_EVENT_INVALID);    CU_ASSERT_EQUAL(odp_queue_deq(ifnet->spq_def), ODP_EVENT_INVALID);    CU_ASSERT_EQUAL(odp_queue_deq(ifnet->outq_def), ODP_EVENT_INVALID);    if (memcmp(odp_packet_data(odp_packet_from_event(ev)),               in_pkt_data, sizeof(test_frame)))        CU_FAIL("corrupt data sent to slow path");    odp_packet_free(odp_packet_from_event(ev));    CU_PASS("ofp_packet_input_to_sp");}

void test_class_db_object(void) {    db_object_field_list_t* local_object_field_list = object_field_list;    db_backend_meta_data_list_t* local_backend_meta_data_list = backend_meta_data_list;    CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));    CU_ASSERT(!db_object_set_connection(object, connection));    CU_ASSERT(!db_object_set_table(object, "table"));    CU_ASSERT(!db_object_set_primary_key_name(object, "primary_key"));    CU_ASSERT(!db_object_set_object_field_list(object, object_field_list));    object_field_list = NULL;    CU_ASSERT(!db_object_set_backend_meta_data_list(object, backend_meta_data_list));    backend_meta_data_list = NULL;    CU_ASSERT(db_object_connection(object) == connection);    CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_table(object));    CU_ASSERT(!strcmp(db_object_table(object), "table"));    CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_primary_key_name(object));    CU_ASSERT(!strcmp(db_object_primary_key_name(object), "primary_key"));    CU_ASSERT(db_object_object_field_list(object) == local_object_field_list);    CU_ASSERT(db_object_backend_meta_data_list(object) == local_backend_meta_data_list);    CU_ASSERT(!db_object_create(object, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer));    CU_ASSERT(db_object_read(object, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer) == (db_result_list_t*)&fake_pointer);    CU_ASSERT(!db_object_update(object, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));    CU_ASSERT(!db_object_delete(object, (db_clause_list_t*)&fake_pointer));    CU_ASSERT(!db_object_count(object, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer, (size_t*)&fake_pointer));    db_object_free(object);    object = NULL;    CU_PASS("db_object_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);}

voidtest_writesame10_simple(void){	int i, ret;	unsigned char *buf = alloca(block_size);	CHECK_FOR_DATALOSS;	CHECK_FOR_SBC;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the start of the LUN");	memset(buf, 0, block_size);	for (i = 1; i <= 256; i++) {		ret = writesame10(sd, 0,				  block_size, i, 0, 0, 0, 0, buf,				  EXPECT_STATUS_GOOD);		if (ret == -2) {			CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");			return;		}		CU_ASSERT_EQUAL(ret, 0);	}	logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the end of the LUN");	for (i = 1; i <= 256; i++) {		ret = writesame10(sd, num_blocks - i,				  block_size, i, 0, 0, 0, 0, buf,				  EXPECT_STATUS_GOOD);		CU_ASSERT_EQUAL(ret, 0);	}}

voidtest_prout_reserve_ownership_ea(void){	struct scsi_device sd2;	if (sd->iscsi_ctx == NULL) {		const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "			"only supported for iSCSI backends";		logging(LOG_NORMAL, "%s", err);		CU_PASS(err);		return;	}	memset(&sd2, 0, sizeof(sd2));	sd2.iscsi_url = sd->iscsi_url;	sd2.iscsi_lun = sd->iscsi_lun;	sd2.iscsi_ctx = iscsi_context_login(initiatorname2, sd2.iscsi_url, &sd2.iscsi_lun);	if (sd2.iscsi_ctx == NULL) {		logging(LOG_VERBOSE, "Failed to login to target");		return;	}	verify_persistent_reserve_ownership(sd, &sd2,	    SCSI_PERSISTENT_RESERVE_TYPE_EXCLUSIVE_ACCESS, 0);	iscsi_destroy_context(sd2.iscsi_ctx);}

voidtest_prefetch10_flags(void){ 	int ret;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test PREFETCH10 flags");	logging(LOG_VERBOSE, "Test PREFETCH10 with IMMED==1");	ret = prefetch10(sd, 0, 1, 1, 0,			 EXPECT_STATUS_GOOD);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] PREFETCH10 is not implemented.");		CU_PASS("PREFETCH10 is not implemented.");		return;	}		CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test PREFETCH10 with GROUP==3");	ret = prefetch10(sd, 0, 1, 0, 3,			 EXPECT_STATUS_GOOD);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test PREFETCH10 with IMMED=1 and GROUP==3");	ret = prefetch10(sd, 0, 1, 1, 3,			 EXPECT_STATUS_GOOD);	CU_ASSERT_EQUAL(ret, 0);}

voidtest_writesame16_simple(void){	int i, ret;	unsigned char *buf = alloca(block_size);		CHECK_FOR_DATALOSS;	CHECK_FOR_SBC;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test WRITESAME16 of 1-256 blocks at the start of the LUN");	for (i = 1; i <= 256; i++) {		ret = writesame16(iscsic, tgt_lun, 0,				  block_size, i,				  0, 0, 0, 0, buf);		if (ret == -2) {			logging(LOG_NORMAL, "[SKIPPED] WRITEVERIFY16 is not implemented.");			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");			return;		}		CU_ASSERT_EQUAL(ret, 0);	}	logging(LOG_VERBOSE, "Test WRITESAME16 of 1-256 blocks at the end of the LUN");	for (i = 1; i <= 256; i++) {		ret = writesame16(iscsic, tgt_lun, num_blocks - i,				  block_size, i,				  0, 0, 0, 0, buf);		CU_ASSERT_EQUAL(ret, 0);	}}

voidtest_prefetch10_0blocks(void){        logging(LOG_VERBOSE, LOG_BLANK_LINE);        logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==0");        PREFETCH10(sd, 0, 0, 0, 0,                   EXPECT_STATUS_GOOD);        if (num_blocks > 0x80000000) {                CU_PASS("[SKIPPED] LUN is too big");                return;        }        logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks one block past end-of-LUN");        PREFETCH10(sd, num_blocks + 1, 0, 0, 0,                   EXPECT_LBA_OOB);        logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==2^31");        PREFETCH10(sd, 0x80000000, 0, 0, 0,                   EXPECT_LBA_OOB);        logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==-1");        PREFETCH10(sd, -1, 0, 0, 0,                   EXPECT_LBA_OOB);}

voidtest_prout_register_simple(void){        const unsigned long long key = rand_key();        int ret = 0;        logging(LOG_VERBOSE, LOG_BLANK_LINE);        logging(LOG_VERBOSE, "Test Persistent Reserve IN REGISTER works.");        /* register our reservation key with the target */        ret = prout_register_and_ignore(sd, key);        if (ret == -2) {                logging(LOG_NORMAL, "[SKIPPED] PERSISTEN RESERVE OUT is not implemented.");                CU_PASS("PERSISTENT RESERVE OUT is not implemented.");                return;        }                CU_ASSERT_EQUAL(ret, 0);        /* verify we can read the registration */        ret = prin_verify_key_presence(sd, key, 1);        CU_ASSERT_EQUAL(ret, 0);        /* try to reregister, which should fail */        ret = prout_reregister_key_fails(sd, key+1);        CU_ASSERT_EQUAL(ret, 0);        /* release from the target */        ret = prout_register_key(sd, 0, key);        CU_ASSERT_EQUAL(ret, 0);        /* Verify the registration is gone */        ret = prin_verify_key_presence(sd, key, 0);        CU_ASSERT_EQUAL(ret, 0);}

voidtest_prin_serviceaction_range(void){	int ret = 0;	int i;	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test Persistent Reserve IN Serviceaction range.");	/* verify PRIN/READ_KEYS works -- XXX redundant -- remove this? */	ret = prin_read_keys(iscsic, tgt_lun, &task, NULL);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] PERSISTEN RESERVE IN is not implemented.");		CU_PASS("PERSISTENT RESERVE IN is not implemented.");		return;	}		CU_ASSERT_EQUAL(ret, 0);	/* verify that PRIN/SA={0,1,2,3} works ... */	for (i = 0; i < 4; i++) {		ret = prin_task(iscsic, tgt_lun, i, 1);		CU_ASSERT_EQUAL(ret, 0);	}	/*  verify that PRIN/SA={4..0x20} fails ... */	for (i = 4; i < 0x20; i++) {		ret = prin_task(iscsic, tgt_lun, i, 0);		CU_ASSERT_EQUAL(ret, 0);	}}

voidtest_verify10_flags(void){	int ret;	unsigned char *buf = malloc(block_size);	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test VERIFY10 flags");	ret = read10(sd, NULL, 0, block_size,		     block_size, 0, 0, 0, 0, 0, buf,		     EXPECT_STATUS_GOOD);	CU_ASSERT_EQUAL(ret, 0);	logging(LOG_VERBOSE, "Test VERIFY10 with BYTCHK==1");	ret = verify10(sd, 0, block_size,		       block_size, 0, 0, 1, buf,		       EXPECT_STATUS_GOOD);	if (ret == -2) {		logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");		CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");		free(buf);		return;	}	CU_ASSERT_EQUAL(ret, 0);	free(buf);}

voidtest_writesame16_wrprotect(void){	int i, ret;	unsigned char *buf = alloca(block_size);	/*	 * Try out different non-zero values for WRPROTECT.	 */	logging(LOG_VERBOSE, LOG_BLANK_LINE);	logging(LOG_VERBOSE, "Test WRITESAME16 with non-zero WRPROTECT");	CHECK_FOR_DATALOSS;	CHECK_FOR_SBC;	memset(buf, 0, block_size);	if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {		logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");		for (i = 1; i < 8; i++) {			ret = writesame16(sd, 0,					  block_size, 1, 0, 0, i, 0, buf,					  EXPECT_INVALID_FIELD_IN_CDB);			if (ret == -2) {				logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");				CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");				return;			}			CU_ASSERT_EQUAL(ret, 0);		}		return;	}	logging(LOG_NORMAL, "No tests for devices that support protection information yet.");}