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

Tests: add helpers for PREFETCH*

Browse Source 
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
This commit is contained in:
Ronnie Sahlberg
2016-02-21 11:25:58 -08:00
parent 9d7103e5ac
commit d910bab852
9 changed files with 86 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -223,6 +223,34 @@ do { \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define PREFETCH10(...) \
do { \
int _r; \
_r = prefetch10(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] PREFETCH10 " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"PREFETCH10. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define PREFETCH16(...) \
do { \
int _r; \
_r = prefetch16(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] PREFETCH16 " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"PREFETCH16. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define READ6(...) \
do { \
int _r; \

30
test-tool/test_prefetch10_0blocks.c
View File

@@ -27,18 +27,11 @@
void
test_prefetch10_0blocks(void)
{
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==0");
ret = prefetch10(sd, 0, 0, 0, 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);
PREFETCH10(sd, 0, 0, 0, 0,
EXPECT_STATUS_GOOD);
if (num_blocks > 0x80000000) {
CU_PASS("[SKIPPED] LUN is too big");
@@ -46,19 +39,14 @@ test_prefetch10_0blocks(void)
}
logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks one block past end-of-LUN");
ret = prefetch10(sd, num_blocks + 1, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, num_blocks + 1, 0, 0, 0,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==2^31");
ret = prefetch10(sd, 0x80000000, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, 0x80000000, 0, 0, 0,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test PREFETCH10 0-blocks at LBA==-1");
ret = prefetch10(sd, -1, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, -1, 0, 0, 0,
EXPECT_LBA_OOB);
}

30
test-tool/test_prefetch10_beyond_eol.c
View File

@@ -28,7 +28,7 @@
void
test_prefetch10_beyond_eol(void)
{
int i, ret;
int i;
if (num_blocks >= 0x80000000) {
CU_PASS("LUN is too big for read-beyond-eol tests with PREFETCH10. Skipping test.\n");
@@ -38,37 +38,25 @@ test_prefetch10_beyond_eol(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH10 1-256 blocks one block beyond the end");
for (i = 1; i <= 256; i++) {
ret = prefetch10(sd, num_blocks + 1 - i, i, 0, 0,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] PREFETCH10 is not implemented.");
CU_PASS("PREFETCH10 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, num_blocks + 1 - i, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH10 1-256 blocks at LBA==2^31");
for (i = 1; i <= 256; i++) {
ret = prefetch10(sd, 0x80000000, i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, 0x80000000, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH10 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
ret = prefetch10(sd, -1, i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, -1, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH10 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
ret = prefetch10(sd, num_blocks - 1, i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, num_blocks - 1, i, 0, 0,
EXPECT_LBA_OOB);
}
}

22
test-tool/test_prefetch10_flags.c
View File

@@ -29,28 +29,18 @@
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);
PREFETCH10(sd, 0, 1, 1, 0,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test PREFETCH10 with GROUP==3");
ret = prefetch10(sd, 0, 1, 0, 3,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, 0, 1, 0, 3,
EXPECT_STATUS_GOOD);
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);
PREFETCH10(sd, 0, 1, 1, 3,
EXPECT_STATUS_GOOD);
}

17
test-tool/test_prefetch10_simple.c
View File

@@ -29,26 +29,19 @@
void
test_prefetch10_simple(void)
{
int i, ret;
int i;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH10 of 1-256 blocks at the start of the LUN");
for (i = 1; i <= 256; i++) {
ret = prefetch10(sd, 0, i, 0, 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);
PREFETCH10(sd, 0, i, 0, 0,
EXPECT_STATUS_GOOD);
}
logging(LOG_VERBOSE, "Test PREFETCH10 of 1-256 blocks at the end of the LUN");
for (i = 1; i <= 256; i++) {
ret = prefetch10(sd, num_blocks - i, i, 0, 0,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH10(sd, num_blocks - i, i, 0, 0,
EXPECT_STATUS_GOOD);
}
}

30
test-tool/test_prefetch16_0blocks.c
View File

@@ -27,33 +27,21 @@
void
test_prefetch16_0blocks(void)
{
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH16 0-blocks at LBA==0");
ret = prefetch16(sd, 0, 0, 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);
PREFETCH16(sd, 0, 0, 0, 0,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test PREFETCH16 0-blocks one block past end-of-LUN");
ret = prefetch16(sd, num_blocks + 1, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, num_blocks + 1, 0, 0, 0,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test PREFETCH16 0-blocks at LBA==2^63");
ret = prefetch16(sd, 0x8000000000000000ULL, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, 0x8000000000000000ULL, 0, 0, 0,
EXPECT_LBA_OOB);
logging(LOG_VERBOSE, "Test PREFETCH16 0-blocks at LBA==-1");
ret = prefetch16(sd, -1, 0, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, -1, 0, 0, 0,
EXPECT_LBA_OOB);
}

31
test-tool/test_prefetch16_beyond_eol.c
View File

@@ -28,43 +28,30 @@
void
test_prefetch16_beyond_eol(void)
{
int i, ret;
int i;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH16 1-256 blocks one block beyond the end");
for (i = 1; i <= 256; i++) {
ret = prefetch16(sd, num_blocks + 1 - i, i, 0, 0,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] PREFETCH16 is not implemented.");
CU_PASS("PREFETCH16 is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, num_blocks + 1 - i, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH16 1-256 blocks at LBA==2^63");
for (i = 1; i <= 256; i++) {
ret = prefetch16(sd, 0x8000000000000000ULL,
i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, 0x8000000000000000ULL, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH16 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
ret = prefetch16(sd, -1, i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, -1, i, 0, 0,
EXPECT_LBA_OOB);
}
logging(LOG_VERBOSE, "Test PREFETCH16 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
ret = prefetch16(sd, num_blocks - 1, i, 0, 0,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, num_blocks - 1, i, 0, 0,
EXPECT_LBA_OOB);
}
}

22
test-tool/test_prefetch16_flags.c
View File

@@ -29,28 +29,18 @@
void
test_prefetch16_flags(void)
{
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test PREFETCH16 flags");
logging(LOG_VERBOSE, "Test PREFETCH16 with IMMED==1");
ret = prefetch16(sd, 0, 1, 1, 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);
PREFETCH16(sd, 0, 1, 1, 0,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test PREFETCH16 with GROUP==3");
ret = prefetch16(sd, 0, 1, 0, 3,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, 0, 1, 0, 3,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test PREFETCH16 with IMMED=1 and GROUP==3");
ret = prefetch16(sd, 0, 1, 1, 3,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
PREFETCH16(sd, 0, 1, 1, 3,
EXPECT_STATUS_GOOD);
}

17
test-tool/test_prefetch16_simple.c
View File

@@ -29,26 +29,19 @@
void
test_prefetch16_simple(void)
{
int i, ret;
int i;
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);
PREFETCH16(sd, 0, i, 0, 0,
EXPECT_STATUS_GOOD);
}
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);
PREFETCH16(sd, num_blocks - i, i, 0, 0,
EXPECT_STATUS_GOOD);
}
}