admin/libiscsi
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Tests: Add helper macros for Write*

Browse Source 
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
This commit is contained in:
Ronnie Sahlberg
2016-02-20 19:33:02 -08:00
parent bd29dab95b
commit eba1ac059a
29 changed files with 252 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
test-tool/iscsi-support.h
View File

@@ -181,6 +181,48 @@ do { \
} \
} while (0);
#define WRITE10(...) \
do { \
int _r; \
_r = write10(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] WRITE10 " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"WRITE10. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define WRITE12(...) \
do { \
int _r; \
_r = write12(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] WRITE12 " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"WRITE12. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define WRITE16(...) \
do { \
int _r; \
_r = write16(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] WRITE16 " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"WRITE16. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define WRITEVERIFY10(...) \
do { \
int _r; \

33
test-tool/test_write10_0blocks.c
View File

@@ -27,21 +27,12 @@
void
test_write10_0blocks(void)
{
int ret;
CHECK_FOR_DATALOSS;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITE10 0-blocks at LBA==0");
ret = write10(sd, 0, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE10 is not implemented.");
CU_PASS("WRITE10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (num_blocks >= 0x80000000) {
CU_PASS("LUN is too big for read-beyond-eol tests with WRITE10. Skipping test.\n");
@@ -49,22 +40,14 @@ test_write10_0blocks(void)
}
logging(LOG_VERBOSE, "Test WRITE10 0-blocks one block past end-of-LUN");
ret = write10(sd, num_blocks + 1, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks + 1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE10 0-blocks at LBA==2^31");
ret = write10(sd, 0x80000000, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0x80000000, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE10 0-blocks at LBA==-1");
ret = write10(sd, -1, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, -1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
}

38
test-tool/test_write10_beyond_eol.c
View File

@@ -29,7 +29,7 @@
void
test_write10_beyond_eol(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
CHECK_FOR_DATALOSS;
@@ -46,50 +46,38 @@ test_write10_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE10 is not implemented.");
CU_PASS("WRITE10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE10 1-256 blocks at LBA==2^31");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, 0x80000000,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0x80000000,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE10 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE10 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
}

35
test-tool/test_write10_dpofua.c
View File

@@ -63,41 +63,30 @@ test_write10_dpofua(void)
logging(LOG_VERBOSE, "Test WRITE10 with DPO==1");
memset(buf, 0xa6, block_size);
if (dpofua) {
ret = write10(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write10(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE10 with FUA==1");
if (dpofua) {
ret = write10(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write10(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE10 with DPO==1 FUA==1");
if (dpofua) {
ret = write10(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
WRITE10(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
} else {
ret = write10(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}

40
test-tool/test_write10_flags.c
View File

@@ -30,7 +30,6 @@
void
test_write10_flags(void)
{
int ret;
unsigned char *buf = alloca(block_size);
CHECK_FOR_DATALOSS;
@@ -40,41 +39,22 @@ test_write10_flags(void)
logging(LOG_VERBOSE, "Test WRITE10 with DPO==1");
memset(buf, 0xa6, block_size);
ret = write10(sd, 0,
block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE10 is not implemented.");
CU_PASS("WRITE10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE10 with FUA==1 FUA_NV==0");
ret = write10(sd, 0,
block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE10 with FUA==1 FUA_NV==1");
ret = write10(sd, 0,
block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE10 with FUA==0 FUA_NV==1");
ret = write10(sd, 0,
block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE10 with DPO==1 FUA==1 FUA_NV==1");
ret = write10(sd, 0,
block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
}

12
test-tool/test_write10_residuals.c
View File

@@ -251,10 +251,8 @@ test_write10_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write10(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -327,10 +325,8 @@ test_write10_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write10(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));

21
test-tool/test_write10_simple.c
View File

@@ -30,7 +30,7 @@
void
test_write10_simple(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
@@ -43,15 +43,8 @@ test_write10_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, 0, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE10 is not implemented.");
CU_PASS("WRITE10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
logging(LOG_VERBOSE, "Test WRITE10 of 1-256 blocks at the end of the LUN");
@@ -59,10 +52,8 @@ test_write10_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
}

15
test-tool/test_write10_wrprotect.c
View File

@@ -30,7 +30,7 @@
void
test_write10_wrprotect(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(block_size);
/*
@@ -46,16 +46,9 @@ test_write10_wrprotect(void)
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 = write10(sd, 0,
block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE10 is not implemented.");
CU_PASS("WRITE10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
return;
}

33
test-tool/test_write12_0blocks.c
View File

@@ -27,8 +27,6 @@
void
test_write12_0blocks(void)
{
int ret;
CHECK_FOR_DATALOSS;
if (num_blocks >= 0x80000000) {
@@ -38,33 +36,18 @@ test_write12_0blocks(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITE12 0-blocks at LBA==0");
ret = write12(sd, 0, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE12 0-blocks one block past end-of-LUN");
ret = write12(sd, num_blocks + 1, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, num_blocks + 1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE12 0-blocks at LBA==2^31");
ret = write12(sd, 0x80000000, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0x80000000, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE12 0-blocks at LBA==-1");
ret = write12(sd, -1, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, -1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
}

38
test-tool/test_write12_beyond_eol.c
View File

@@ -29,7 +29,7 @@
void
test_write12_beyond_eol(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
CHECK_FOR_DATALOSS;
@@ -46,50 +46,38 @@ test_write12_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE12 1-256 blocks at LBA==2^31");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, 0x80000000,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0x80000000,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE12 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE12 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
}

46
test-tool/test_write12_dpofua.c
View File

@@ -63,51 +63,29 @@ test_write12_dpofua(void)
logging(LOG_VERBOSE, "Test WRITE12 with DPO==1");
memset(buf, 0xa6, block_size);
if (dpofua) {
ret = write12(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write12(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE12 with FUA==1");
if (dpofua) {
ret = write12(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write12(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE12 with DPO==1 FUA==1");
if (dpofua) {
ret = write12(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write12(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}

40
test-tool/test_write12_flags.c
View File

@@ -30,7 +30,6 @@
void
test_write12_flags(void)
{
int ret;
unsigned char *buf = alloca(block_size);
CHECK_FOR_DATALOSS;
@@ -40,41 +39,22 @@ test_write12_flags(void)
logging(LOG_VERBOSE, "Test WRITE12 with DPO==1");
memset(buf, 0xa6, block_size);
ret = write12(sd, 0,
block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE12 with FUA==1 FUA_NV==0");
ret = write12(sd, 0,
block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE12 with FUA==1 FUA_NV==1");
ret = write12(sd, 0,
block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE12 with FUA==0 FUA_NV==1");
ret = write12(sd, 0,
block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE12 with DPO==1 FUA==1 FUA_NV==1");
ret = write12(sd, 0,
block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
}

12
test-tool/test_write12_residuals.c
View File

@@ -250,10 +250,8 @@ test_write12_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write12(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -326,10 +324,8 @@ test_write12_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write12(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));

21
test-tool/test_write12_simple.c
View File

@@ -30,7 +30,7 @@
void
test_write12_simple(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
CHECK_FOR_DATALOSS;
@@ -42,15 +42,8 @@ test_write12_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, 0, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
logging(LOG_VERBOSE, "Test WRITE12 of 1-256 blocks at the end of the LUN");
@@ -58,10 +51,8 @@ test_write12_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write12(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
}

15
test-tool/test_write12_wrprotect.c
View File

@@ -30,7 +30,7 @@
void
test_write12_wrprotect(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(block_size);
@@ -47,16 +47,9 @@ test_write12_wrprotect(void)
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 = write12(sd, 0,
block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE12 is not implemented.");
CU_PASS("WRITE12 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
return;
}

33
test-tool/test_write16_0blocks.c
View File

@@ -27,40 +27,23 @@
void
test_write16_0blocks(void)
{
int ret;
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITE16 0-blocks at LBA==0");
ret = write16(sd, 0, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE16 0-blocks one block past end-of-LUN");
ret = write16(sd, num_blocks + 1, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, num_blocks + 1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE16 0-blocks at LBA==2^63");
ret = write16(sd, 0x8000000000000000ULL, 0,
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0x8000000000000000ULL, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test WRITE16 0-blocks at LBA==-1");
ret = write16(sd, -1, 0, block_size,
0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, -1, 0, block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
}

39
test-tool/test_write16_beyond_eol.c
View File

@@ -29,7 +29,7 @@
void
test_write16_beyond_eol(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
@@ -43,51 +43,38 @@ test_write16_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE16 1-256 blocks at LBA==2^63");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, 0x8000000000000000ULL,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0x8000000000000000ULL,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE16 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, -1, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test WRITE16 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, num_blocks - 1,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
}
}

45
test-tool/test_write16_dpofua.c
View File

@@ -63,51 +63,30 @@ test_write16_dpofua(void)
logging(LOG_VERBOSE, "Test WRITE16 with DPO==1");
memset(buf, 0xa6, block_size);
if (dpofua) {
ret = write16(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write16(sd, 0, block_size,
block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE16 with FUA==1");
if (dpofua) {
ret = write16(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
ret = write16(sd, 0, block_size,
block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
logging(LOG_VERBOSE, "Test WRITE16 with DPO==1 FUA==1");
if (dpofua) {
ret = write16(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
WRITE16(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
} else {
ret = write16(sd, 0, block_size,
block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}

40
test-tool/test_write16_flags.c
View File

@@ -30,7 +30,6 @@
void
test_write16_flags(void)
{
int ret;
unsigned char *buf = alloca(block_size);
CHECK_FOR_DATALOSS;
@@ -41,41 +40,22 @@ test_write16_flags(void)
logging(LOG_VERBOSE, "Test WRITE16 with DPO==1");
memset(buf, 0xa6, block_size);
ret = write16(sd, 0,
block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 1, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE16 with FUA==1 FUA_NV==0");
ret = write16(sd, 0,
block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE16 with FUA==1 FUA_NV==1");
ret = write16(sd, 0,
block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 0, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE16 with FUA==0 FUA_NV==1");
ret = write16(sd, 0,
block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 0, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test WRITE16 with DPO==1 FUA==1 FUA_NV==1");
ret = write16(sd, 0,
block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size, 0, 1, 1, 1, 0, buf,
EXPECT_STATUS_GOOD);
}

12
test-tool/test_write16_residuals.c
View File

@@ -250,10 +250,8 @@ test_write16_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write16(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -326,10 +324,8 @@ test_write16_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write16(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));

21
test-tool/test_write16_simple.c
View File

@@ -30,7 +30,7 @@
void
test_write16_simple(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(256 * block_size);
@@ -44,15 +44,8 @@ test_write16_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, 0, i * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
logging(LOG_VERBOSE, "Test WRITE16 of 1-256 blocks at the end of the LUN");
@@ -60,10 +53,8 @@ test_write16_simple(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = write16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
}
}

15
test-tool/test_write16_wrprotect.c
View File

@@ -30,7 +30,7 @@
void
test_write16_wrprotect(void)
{
int i, ret;
int i;
unsigned char *buf = alloca(block_size);
/*
@@ -46,16 +46,9 @@ test_write16_wrprotect(void)
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 = write16(sd, 0,
block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITE16 is not implemented.");
CU_PASS("WRITE16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, block_size, block_size,
i, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
return;
}

20
test-tool/test_writesame10_unmap.c
View File

@@ -46,10 +46,8 @@ test_writesame10_unmap(void)
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write10(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);
@@ -81,10 +79,9 @@ test_writesame10_unmap(void)
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);
@@ -153,10 +150,9 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write10(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);

7
test-tool/test_writesame10_unmap_until_end.c
View File

@@ -50,10 +50,9 @@ test_writesame10_unmap_until_end(void)
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(sd, num_blocks - i,

27
test-tool/test_writesame16_unmap.c
View File

@@ -44,9 +44,9 @@ test_writesame16_unmap(void)
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write16(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
WRITE16(sd, 0, i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(sd, 0,
@@ -80,10 +80,9 @@ test_writesame16_unmap(void)
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
@@ -150,10 +149,9 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write16(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
@@ -200,10 +198,9 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, i * block_size);
ret = write16(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);

7
test-tool/test_writesame16_unmap_until_end.c
View File

@@ -51,9 +51,10 @@ test_writesame16_unmap_until_end(void)
for (i = 1; i <= 256; i++) {
logging(LOG_VERBOSE, "Write %d blocks of 0xFF", i);
memset(buf, 0xff, block_size * i);
ret = write16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
WRITE16(sd, num_blocks - i,
i * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(sd, num_blocks - i,

12
test-tool/test_writeverify10_residuals.c
View File

@@ -255,10 +255,8 @@ test_writeverify10_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write10(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -331,10 +329,8 @@ test_writeverify10_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write10(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE10(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));

12
test-tool/test_writeverify12_residuals.c
View File

@@ -255,10 +255,8 @@ test_writeverify12_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write12(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -331,10 +329,8 @@ test_writeverify12_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write12(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE12(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));

14
test-tool/test_writeverify16_residuals.c
View File

@@ -257,16 +257,12 @@ test_writeverify16_residuals(void)
task = NULL;
logging(LOG_VERBOSE, "Verify that if iSCSI EDTL > SCSI TL then we only write SCSI TL amount of data");
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write16(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write one block of 'b' but set iSCSI EDTL to 2 blocks.");
task = malloc(sizeof(struct scsi_task));
@@ -339,10 +335,8 @@ test_writeverify16_residuals(void)
logging(LOG_VERBOSE, "Write two blocks of 'a'");
memset(buf, 'a', 10000);
ret = write16(sd, 0, 2 * block_size,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
WRITE16(sd, 0, 2 * block_size, block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Write two blocks of 'b' but set iSCSI EDTL to 1 blocks.");
task = malloc(sizeof(struct scsi_task));