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_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; }
void test_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); }
void test_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)); }
void test_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."); }
void test_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"); }
void test_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; } }
void test_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); }
void test_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 void test_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"); }
void test_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); }
void test_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."); }
void test_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."); }
void test_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); }
void test_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); } }
void test_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 void test_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); }
void test_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); } }
void test_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); }
void test_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); }
void test_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); } }
void test_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); }
void test_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); }
void test_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); } }
void test_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); }
void test_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."); }