diff --git a/test-tool/iscsi-support.c b/test-tool/iscsi-support.c
index 670b7e8..7f483bc 100644
--- a/test-tool/iscsi-support.c
+++ b/test-tool/iscsi-support.c
@@ -3618,549 +3618,81 @@ write16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, in
 }
 
 int
-writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
+writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
 {
 	struct scsi_task *task;
-	uint64_t realdatalen;
+	struct iscsi_data d;
+	int ret;
 
-	logging(LOG_VERBOSE, "Send WRITESAME10 LBA:%d blocks:%d "
-	       "wrprotect:%d anchor:%d unmap:%d group:%d",
-	       lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame10_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
-		if (inq_bl->wsnz == 1 && num == 0) {
-			logging(LOG_NORMAL, "[SKIPPED] Target does not support WRITESAME10 with NUMBER OF LOGICAL BLOCKS == 0");
-			scsi_free_scsi_task(task);
-			return -3;
-		}
-
-		if (datalen == 0) {
-			realdatalen = num_blocks;
-		} else {
-			realdatalen = datalen;
-		}
-		if (inq_bl->max_ws_len > 0 && realdatalen > inq_bl->max_ws_len) {
-			logging(LOG_NORMAL, "[SKIPPED] Number of WRITESAME10 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");
-			scsi_free_scsi_task(task);
-			return -4;
-		}
-	}
-	if (task->status != SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 command: "
-			"failed with sense. %s", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME10 returned SUCCESS.");
-	return 0;
-}
-
-int
-writesame10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting LBA_OUT_OF_RANGE) "
-		"LBA:%d blocks:%d "
+	logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting %s) LBA:%d blocks:%d "
 		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
+		scsi_status_str(status),
+		lba, num, wrprotect, anchor, unmap_flag, group);
 
 	if (!data_loss) {
 		printf("--dataloss flag is not set in. Skipping write\n");
 		return -1;
 	}
 
-	task = iscsi_writesame10_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
-			"have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-		|| task->sense.key  != SCSI_SENSE_ILLEGAL_REQUEST
-		|| task->sense.ascq != SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
-			"Should have failed with ILLEGAL_REQUEST/"
-			"LBA_OUT_OF_RANGE. Sense:%s\n", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
+	task = scsi_cdb_writesame10(wrprotect, anchor, unmap_flag, lba, group,
+				    num, datalen);
+	assert(task != NULL);
+
+	if (data != NULL) {
+		task->expxferlen = datalen;
+	} else {
+		task->expxferlen = 0;
+		task->xfer_dir = SCSI_XFER_NONE;
 	}
 
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME10 returned ILLEGAL_REQUEST/LBA_OUT_OF_RANGE.");
-	return 0;
+	d.data = data;
+	d.size = datalen;
+	task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
+
+	ret = check_result("WRITESAME10", iscsi, task, status, key, ascq, num_ascq);
+	if (task) {
+		scsi_free_scsi_task(task);
+	}
+	return ret;
 }
 
 int
-writesame10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
+writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
 {
 	struct scsi_task *task;
+	struct iscsi_data d;
+	int ret;
 
-	logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting INVALID_FIELD_IN_CDB) "
-		"LBA:%d blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
+	logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting %s) LBA:%" PRIu64
+		" blocks:%d wrprotect:%d anchor:%d unmap:%d group:%d",
+		scsi_status_str(status),
+		lba, num, wrprotect, anchor, unmap_flag, group);
 
 	if (!data_loss) {
 		printf("--dataloss flag is not set in. Skipping write\n");
 		return -1;
 	}
 
-	task = iscsi_writesame10_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
+	task = scsi_cdb_writesame16(wrprotect, anchor, unmap_flag, lba, group,
+				    num, datalen);
+	assert(task != NULL);
+
+	if (data != NULL) {
+		task->expxferlen = datalen;
+	} else {
+		task->expxferlen = 0;
+		task->xfer_dir = SCSI_XFER_NONE;
 	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
+
+	d.data = data;
+	d.size = datalen;
+	task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
+
+	ret = check_result("WRITESAME16", iscsi, task, status, key, ascq, num_ascq);
+	if (task) {
 		scsi_free_scsi_task(task);
-		return -2;
 	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
-			"have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-		|| task->sense.key  != SCSI_SENSE_ILLEGAL_REQUEST
-		|| task->sense.ascq != SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
-			"Should have failed with ILLEGAL_REQUEST/"
-			"INVALID_FIELD_IN_CDB. Sense:%s\n",
-			iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME10 returned ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB.");
-	return 0;
-}
-
-int
-writesame10_writeprotected(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting WRITE_PROTECTED) "
-		"LBA:%d blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame10_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
-			"have failed with DATA_PROTECTION/WRITE_PROTECTED");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-	    || task->sense.key  != SCSI_SENSE_DATA_PROTECTION
-	    || task->sense.ascq != SCSI_SENSE_ASCQ_WRITE_PROTECTED) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
-			"Should have failed with DATA_PROTECTION/"
-			"WRITE_PROTECTED. Sense:%s\n", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME10 returned DATA_PROTECTION/WRITE_PROTECTED.");
-	return 0;
-}
-
-int
-writesame10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting MEDIUM_NOT_PRESENT) "
-		"LBA:%d blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame10_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-	  logging(LOG_NORMAL, "[FAILED] WRITESAME10 command successful. But should have failed with NOT_READY/MEDIUM_NOT_PRESENT*");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-	    || task->sense.key  != SCSI_SENSE_NOT_READY
-	    || (task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT
-	        && task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN
-	        && task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED)) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME10 Should have failed "
-			"with NOT_READY/MEDIUM_NOT_PRESENT* But failed "
-			"with %s", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}	
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME10 returned MEDIUM_NOT_PRESENT.");
-	return 0;
-}
-
-int
-writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-	uint64_t realdatalen;
-
-	logging(LOG_VERBOSE, "Send WRITESAME16 LBA:%" PRIu64 " blocks:%d "
-	       "wrprotect:%d anchor:%d unmap:%d group:%d",
-	       lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame16_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
-		if (inq_bl->wsnz == 1 && num == 0) {
-			logging(LOG_NORMAL, "[SKIPPED] Target does not support WRITESAME16 with NUMBER OF LOGICAL BLOCKS == 0");
-			scsi_free_scsi_task(task);
-			return -3;
-		}
-
-		if (datalen == 0) {
-			realdatalen = num_blocks;
-		} else {
-			realdatalen = datalen;
-		}
-		if (inq_bl->max_ws_len > 0 && realdatalen > inq_bl->max_ws_len) {
-			logging(LOG_NORMAL, "[SKIPPED] Number of WRITESAME16 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");
-			scsi_free_scsi_task(task);
-			return -4;
-		}
-	}
-	if (task->status != SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 command: "
-			"failed with sense. %s", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME16 returned SUCCESS.");
-	return 0;
-}
-
-int
-writesame16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting LBA_OUT_OF_RANGE) "
-		"LBA:%" PRIu64 " blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame16_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
-			"have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-		|| task->sense.key  != SCSI_SENSE_ILLEGAL_REQUEST
-		|| task->sense.ascq != SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
-			"Should have failed with ILLEGAL_REQUEST/"
-			"LBA_OUT_OF_RANGE. Sense:%s\n", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME16 returned ILLEGAL_REQUEST/LBA_OUT_OF_RANGE.");
-	return 0;
-}
-
-int
-writesame16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting INVALID_FIELD_IN_CDB) "
-		"LBA:%" PRIu64 " blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame16_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
-			"have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-		|| task->sense.key  != SCSI_SENSE_ILLEGAL_REQUEST
-		|| task->sense.ascq != SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
-			"Should have failed with ILLEGAL_REQUEST/"
-			"INVALID_FIELD_IN_CDB. Sense:%s\n",
-			iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME16 returned ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB.");
-	return 0;
-}
-
-int
-writesame16_writeprotected(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting WRITE_PROTECTED) "
-		"LBA:%" PRIu64 " blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame16_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
-			"have failed with DATA_PROTECTION/WRITE_PROTECTED");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-	    || task->sense.key  != SCSI_SENSE_DATA_PROTECTION
-	    || task->sense.ascq != SCSI_SENSE_ASCQ_WRITE_PROTECTED) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
-			"Should have failed with DATA_PROTECTION/"
-			"WRITE_PROTECTED. Sense:%s\n", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME16 returned DATA_PROTECTION/WRITE_PROTECTED.");
-	return 0;
-}
-
-int
-writesame16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
-{
-	struct scsi_task *task;
-
-	logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting MEDIUM_NOT_PRESENT) "
-		"LBA:%" PRIu64 " blocks:%d "
-		"wrprotect:%d anchor:%d unmap:%d group:%d",
-		lba, num, wrprotect,
-		anchor, unmap_flag, group);
-
-	if (!data_loss) {
-		printf("--dataloss flag is not set in. Skipping write\n");
-		return -1;
-	}
-
-	task = iscsi_writesame16_sync(iscsi, lun, lba, 
-				      data, datalen, num,
-				      anchor, unmap_flag, wrprotect, group);
-	if (task == NULL) {
-		logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
-		       iscsi_get_error(iscsi));
-		return -1;
-	}
-	if (task->status        == SCSI_STATUS_CHECK_CONDITION
-	    && task->sense.key  == SCSI_SENSE_ILLEGAL_REQUEST
-	    && task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
-		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
-		scsi_free_scsi_task(task);
-		return -2;
-	}
-	if (task->status == SCSI_STATUS_GOOD) {
-	  logging(LOG_NORMAL, "[FAILED] WRITESAME16 command successful. But should have failed with NOT_READY/MEDIUM_NOT_PRESENT*");
-		scsi_free_scsi_task(task);
-		return -1;
-	}
-	if (task->status        != SCSI_STATUS_CHECK_CONDITION
-	    || task->sense.key  != SCSI_SENSE_NOT_READY
-	    || (task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT
-	        && task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN
-	        && task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED)) {
-		logging(LOG_NORMAL, "[FAILED] WRITESAME16 Should have failed "
-			"with NOT_READY/MEDIUM_NOT_PRESENT* But failed "
-			"with %s", iscsi_get_error(iscsi));
-		scsi_free_scsi_task(task);
-		return -1;
-	}	
-
-	scsi_free_scsi_task(task);
-	logging(LOG_VERBOSE, "[OK] WRITESAME16 returned MEDIUM_NOT_PRESENT.");
-	return 0;
+	return ret;
 }
 
 int
diff --git a/test-tool/iscsi-support.h b/test-tool/iscsi-support.h
index b0d8e73..9d5bf42 100644
--- a/test-tool/iscsi-support.h
+++ b/test-tool/iscsi-support.h
@@ -314,16 +314,8 @@ int verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datale
 int write10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
 int write12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
 int write16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
-int writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame10_writeprotected(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame16_writeprotected(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
-int writesame16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
+int writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
+int writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
 int writeverify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
 int writeverify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
 int writeverify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
diff --git a/test-tool/test_nomedia_sbc.c b/test-tool/test_nomedia_sbc.c
index b6bf964..b1a4429 100644
--- a/test-tool/test_nomedia_sbc.c
+++ b/test-tool/test_nomedia_sbc.c
@@ -231,8 +231,9 @@ test_nomedia_sbc(void)
 	logging(LOG_VERBOSE, "[SKIPPED] Test not implemented yet");
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 when medium is ejected.");
-	ret = writesame10_nomedium(iscsic, tgt_lun, 0, block_size,
-				   1, 0, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, 0, block_size,
+			  1, 0, 0, 0, 0, buf,
+			  EXPECT_NO_MEDIUM);
 	if (ret == -2) {
 		logging(LOG_NORMAL, "[SKIPPED] target does not support "
 			"WRITESAME10");
@@ -241,8 +242,9 @@ test_nomedia_sbc(void)
 	}
 
 	logging(LOG_VERBOSE, "Test WRITESAME16 when medium is ejected.");
-	ret = writesame16_nomedium(iscsic, tgt_lun, 0, block_size,
-				   1, 0, 0, 0, 0, buf);
+	ret = writesame16(iscsic, tgt_lun, 0, block_size,
+			  1, 0, 0, 0, 0, buf,
+			  EXPECT_NO_MEDIUM);
 	if (ret == -2) {
 		logging(LOG_NORMAL, "[SKIPPED] target does not support "
 			"WRITESAME16");
diff --git a/test-tool/test_readonly_sbc.c b/test-tool/test_readonly_sbc.c
index c2f45bd..03550f2 100644
--- a/test-tool/test_readonly_sbc.c
+++ b/test-tool/test_readonly_sbc.c
@@ -59,34 +59,36 @@ test_readonly_sbc(void)
 	CU_ASSERT_EQUAL(ret, 0);
 
 	logging(LOG_VERBOSE, "Test WRITE_SAME10 fails with WRITE_PROTECTED");
-	ret = writesame10_writeprotected(iscsic, tgt_lun, 0, block_size, 1,
-					 0, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, 0, block_size, 1,
+			  0, 0, 0, 0, buf,
+			  EXPECT_WRITE_PROTECTED);
 	if (ret == -2) {
 		logging(LOG_VERBOSE, "WRITE_SAME10 not supported on target. Skipped.");
 	}
 	CU_ASSERT_NOT_EQUAL(ret, -1);
 
 	logging(LOG_VERBOSE, "Test WRITE_SAME16 fails with WRITE_PROTECTED");
-	ret = writesame16_writeprotected(iscsic, tgt_lun, 0, block_size, 1,
-					 0, 0, 0, 0, buf);
+	ret = writesame16(iscsic, tgt_lun, 0, block_size, 1,
+			  0, 0, 0, 0, buf,
+			  EXPECT_WRITE_PROTECTED);
 	if (ret == -2) {
 		logging(LOG_VERBOSE, "WRITE_SAME16 not supported on target. Skipped.");
 	}
 	CU_ASSERT_NOT_EQUAL(ret, -1);
 
 	logging(LOG_VERBOSE, "Test WRITE_SAME10 UNMAP fails with WRITE_PROTECTED");
-	ret = writesame10_writeprotected(iscsic, tgt_lun, 0,
-					 block_size, 1,
-					 0, 1, 0, 0, NULL);
+	ret = writesame10(iscsic, tgt_lun, 0,
+			  block_size, 1, 0, 1, 0, 0, NULL,
+			  EXPECT_WRITE_PROTECTED);
 	if (ret == -2) {
 		logging(LOG_VERBOSE, "WRITE_SAME10 not supported on target. Skipped.");
 	}
 	CU_ASSERT_NOT_EQUAL(ret, -1);
 
 	logging(LOG_VERBOSE, "Test WRITE_SAME16 UNMAP fails with WRITE_PROTECTED");
-	ret = writesame16_writeprotected(iscsic, tgt_lun, 0,
-					 block_size, 1,
-					 0, 1, 0, 0, NULL);
+	ret = writesame16(iscsic, tgt_lun, 0,
+			  block_size, 1, 0, 1, 0, 0, NULL,
+			  EXPECT_WRITE_PROTECTED);
 	if (ret == -2) {
 		logging(LOG_VERBOSE, "WRITE_SAME16 not supported on target. Skipped.");
 	}
diff --git a/test-tool/test_writesame10_0blocks.c b/test-tool/test_writesame10_0blocks.c
index 11ac599..a64815a 100644
--- a/test-tool/test_writesame10_0blocks.c
+++ b/test-tool/test_writesame10_0blocks.c
@@ -41,8 +41,8 @@ test_writesame10_0blocks(void)
 	logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==0 (WSNZ=%d)",
 		inq_bl->wsnz);
 	ret = writesame10(iscsic, tgt_lun, 0,
-			  block_size, 0,
-			  0, 0, 0, 0, buf);
+			  block_size, 0, 0, 0, 0, 0, buf,
+			  EXPECT_STATUS_GOOD);
 	if (ret == -2) {
 		CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
 		return;
@@ -59,22 +59,22 @@ test_writesame10_0blocks(void)
 	}
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks one block past end-of-LUN");
-	ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1,
-					block_size, 0,
-					0, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, num_blocks + 1,
+			  block_size, 0, 0, 0, 0, 0, buf,
+			  EXPECT_LBA_OOB);
 	CU_ASSERT_EQUAL(ret, 0);
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==2^31");
-	ret = writesame10_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
-					block_size, 0,
-					0, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, 0x80000000,
+			  block_size, 0, 0, 0, 0, 0, buf,
+			  EXPECT_LBA_OOB);
 	CU_ASSERT_EQUAL(ret, 0);
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==-1");
-	ret = writesame10_lbaoutofrange(iscsic, tgt_lun, -1,
-					block_size, 0,
-					0, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, -1,
+			  block_size, 0, 0, 0, 0, 0, buf,
+			  EXPECT_LBA_OOB);
 	CU_ASSERT_EQUAL(ret, 0);
 }
diff --git a/test-tool/test_writesame10_beyond_eol.c b/test-tool/test_writesame10_beyond_eol.c
index 5eb4b60..ae415a8 100644
--- a/test-tool/test_writesame10_beyond_eol.c
+++ b/test-tool/test_writesame10_beyond_eol.c
@@ -43,9 +43,9 @@ test_writesame10_beyond_eol(void)
 	logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks one block beyond the end");
 	memset(buf, 0, block_size);
 	for (i = 1; i <= 256; i++) {
-		ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks - i + 1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, num_blocks - i + 1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		if (ret == -2) {
 			CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
 			return;
@@ -56,27 +56,27 @@ test_writesame10_beyond_eol(void)
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks at LBA==2^31");
 	for (i = 1; i <= 256; i++) {
-		ret = writesame10_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, 0x80000000,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks at LBA==-1");
 	for (i = 1; i <= 256; i++) {
-		ret = writesame10_lbaoutofrange(iscsic, tgt_lun, -1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, -1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME10 2-256 blocks all but one block beyond the end");
 	for (i = 2; i <= 256; i++) {
-		ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, num_blocks - 1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 }
diff --git a/test-tool/test_writesame10_simple.c b/test-tool/test_writesame10_simple.c
index 3a9c5c3..460ac34 100644
--- a/test-tool/test_writesame10_simple.c
+++ b/test-tool/test_writesame10_simple.c
@@ -1,4 +1,3 @@
-
 /* 
    Copyright (C) 2013 Ronnie Sahlberg <ronniesahlberg@gmail.com>
    
@@ -42,8 +41,8 @@ test_writesame10_simple(void)
 	memset(buf, 0, block_size);
 	for (i = 1; i <= 256; i++) {
 		ret = writesame10(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 0, 0, 0, buf);
+				  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;
@@ -54,8 +53,8 @@ test_writesame10_simple(void)
 	logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the end of the LUN");
 	for (i = 1; i <= 256; i++) {
 		ret = writesame10(iscsic, tgt_lun, num_blocks - i,
-				  block_size, i,
-				  0, 0, 0, 0, buf);
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
diff --git a/test-tool/test_writesame10_unmap.c b/test-tool/test_writesame10_unmap.c
index 69fbc03..bf86961 100644
--- a/test-tool/test_writesame10_unmap.c
+++ b/test-tool/test_writesame10_unmap.c
@@ -52,8 +52,8 @@ test_writesame10_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
 		memset(buf, 0, block_size);
 		ret = writesame10(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -90,8 +90,8 @@ test_writesame10_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
 		memset(buf, 0, block_size);
 		ret = writesame10(iscsic, tgt_lun, num_blocks - i,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -116,9 +116,9 @@ test_writesame10_unmap(void)
 
 	logging(LOG_VERBOSE, "Verify that WRITESAME10 ANCHOR==1 + UNMAP==0 is "
 		"invalid");
-	ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
-					    block_size, 1,
-					    1, 0, 0, 0, buf);
+	ret = writesame10(iscsic, tgt_lun, 0,
+			  block_size, 1, 1, 0, 0, 0, buf,
+			  EXPECT_INVALID_FIELD_IN_CDB);
 	CU_ASSERT_EQUAL(ret, 0);
 
 
@@ -127,14 +127,14 @@ test_writesame10_unmap(void)
 		logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0");
 		memset(buf, 0, block_size);
 		ret = writesame10(iscsic, tgt_lun, 0,
-				  block_size, 1,
-				  1, 1, 0, 0, buf);
+				  block_size, 1, 1, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 	} else {
 		logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0 no "
 			"ANC_SUP so expecting to fail");
-		ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
-						    block_size, 1,
-						    1, 1, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, 0,
+				  block_size, 1, 1, 1, 0, 0, buf,
+				  EXPECT_INVALID_FIELD_IN_CDB);
 	}
 	CU_ASSERT_EQUAL(ret, 0);
 
@@ -165,8 +165,8 @@ test_writesame10_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
 		memset(buf, 0, block_size);
 		ret = writesame10(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -193,9 +193,9 @@ test_writesame10_unmap(void)
 			"INVALID_FIELD_IN_CDB.");
 
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
-		ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+		ret = writesame10(iscsic, tgt_lun, 0,
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_INVALID_FIELD_IN_CDB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 }
diff --git a/test-tool/test_writesame10_unmap_unaligned.c b/test-tool/test_writesame10_unmap_unaligned.c
index 9085500..9936751 100644
--- a/test-tool/test_writesame10_unmap_unaligned.c
+++ b/test-tool/test_writesame10_unmap_unaligned.c
@@ -42,8 +42,8 @@ test_writesame10_unmap_unaligned(void)
 	for (i = 1; i < lbppb; i++) {
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10 at LBA:%d", lbppb - i, i);
 		ret = writesame10(iscsic, tgt_lun, i,
-				  block_size, lbppb - i,
-				  0, 1, 0, 0, buf);
+				  block_size, lbppb - i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 }
diff --git a/test-tool/test_writesame10_unmap_until_end.c b/test-tool/test_writesame10_unmap_until_end.c
index a8308db..e3751eb 100644
--- a/test-tool/test_writesame10_unmap_until_end.c
+++ b/test-tool/test_writesame10_unmap_until_end.c
@@ -54,8 +54,8 @@ test_writesame10_unmap_until_end(void)
 
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
 		ret = writesame10(iscsic, tgt_lun, num_blocks - i,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
diff --git a/test-tool/test_writesame10_unmap_vpd.c b/test-tool/test_writesame10_unmap_vpd.c
index 98a1308..01eb714 100644
--- a/test-tool/test_writesame10_unmap_vpd.c
+++ b/test-tool/test_writesame10_unmap_vpd.c
@@ -43,9 +43,8 @@ test_writesame10_unmap_vpd(void)
 	logging(LOG_VERBOSE, "Unmap 1 block using WRITESAME10");
 	memset(buf, 0, block_size);
 	ret = writesame10(iscsic, tgt_lun, 0,
-			  block_size, 1,
-			  0, 1, 0, 0, buf);
-
+			  block_size, 1, 0, 1, 0, 0, buf,
+			  EXPECT_STATUS_GOOD);
 	if (ret != 0) {
 		logging(LOG_VERBOSE, "WRITESAME10 UNMAP is not available. "
 			"Verify that VPD settings reflect this.");
diff --git a/test-tool/test_writesame10_wrprotect.c b/test-tool/test_writesame10_wrprotect.c
index 579457a..6f0f5d8 100644
--- a/test-tool/test_writesame10_wrprotect.c
+++ b/test-tool/test_writesame10_wrprotect.c
@@ -45,9 +45,9 @@ test_writesame10_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 = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
-							    block_size, 1,
-							    0, 0, i, 0, buf);
+			ret = writesame10(iscsic, tgt_lun, 0,
+					  block_size, 1, 0, 0, i, 0, buf,
+					  EXPECT_INVALID_FIELD_IN_CDB);
 			if (ret == -2) {
 				logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented.");
 				CU_PASS("WRITESAME10 is not implemented.");
diff --git a/test-tool/test_writesame16_0blocks.c b/test-tool/test_writesame16_0blocks.c
index 3223f6b..16e46ab 100644
--- a/test-tool/test_writesame16_0blocks.c
+++ b/test-tool/test_writesame16_0blocks.c
@@ -35,8 +35,8 @@ test_writesame16_0blocks(void)
 	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);
+			  block_size, 0, 0, 0, 0, 0, NULL,
+			  EXPECT_STATUS_GOOD);
 	if (ret == -2) {
 		logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 		CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -54,22 +54,22 @@ test_writesame16_0blocks(void)
 	}
 
 	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);
+	ret = writesame16(iscsic, tgt_lun, num_blocks + 1,
+			  block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
+			  EXPECT_LBA_OOB);
 	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);
+	ret = writesame16(iscsic, tgt_lun, 0x8000000000000000ULL,
+			  block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
+			  EXPECT_LBA_OOB);
 	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);
+	ret = writesame16(iscsic, tgt_lun, -1,
+			  block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
+			  EXPECT_LBA_OOB);
 	CU_ASSERT_EQUAL(ret, 0);
 }
diff --git a/test-tool/test_writesame16_beyond_eol.c b/test-tool/test_writesame16_beyond_eol.c
index ca5dfb7..bfe445e 100644
--- a/test-tool/test_writesame16_beyond_eol.c
+++ b/test-tool/test_writesame16_beyond_eol.c
@@ -38,9 +38,9 @@ test_writesame16_beyond_eol(void)
 	logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks one block beyond the end");
 	memset(buf, 0, block_size);
 	for (i = 1; i <= 256; i++) {
-		ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks - i + 1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, num_blocks - i + 1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		if (ret == -2) {
 			logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -52,27 +52,27 @@ test_writesame16_beyond_eol(void)
 
 	logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks at LBA==2^63");
 	for (i = 1; i <= 256; i++) {
-		ret = writesame16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, 0x8000000000000000ULL,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks at LBA==-1");
 	for (i = 1; i <= 256; i++) {
-		ret = writesame16_lbaoutofrange(iscsic, tgt_lun, -1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, -1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
 
 	logging(LOG_VERBOSE, "Test WRITESAME16 2-256 blocks all but one block beyond the end");
 	for (i = 2; i <= 256; i++) {
-		ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
-						block_size, i,
-						0, 0, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, num_blocks - 1,
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_LBA_OOB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 }
diff --git a/test-tool/test_writesame16_simple.c b/test-tool/test_writesame16_simple.c
index c9ac093..3eba474 100644
--- a/test-tool/test_writesame16_simple.c
+++ b/test-tool/test_writesame16_simple.c
@@ -41,8 +41,8 @@ test_writesame16_simple(void)
 	memset(buf, 0, block_size);
 	for (i = 1; i <= 256; i++) {
 		ret = writesame16(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 0, 0, 0, buf);
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		if (ret == -2) {
 			logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -54,8 +54,8 @@ test_writesame16_simple(void)
 	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);
+				  block_size, i, 0, 0, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
diff --git a/test-tool/test_writesame16_unmap.c b/test-tool/test_writesame16_unmap.c
index 4d2badc..498c9a5 100644
--- a/test-tool/test_writesame16_unmap.c
+++ b/test-tool/test_writesame16_unmap.c
@@ -52,8 +52,8 @@ test_writesame16_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
 		memset(buf, 0, block_size);
 		ret = writesame16(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		if (ret == -2) {
 			logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -91,8 +91,8 @@ test_writesame16_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
 		memset(buf, 0, block_size);
 		ret = writesame16(iscsic, tgt_lun, num_blocks - i,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -113,9 +113,9 @@ test_writesame16_unmap(void)
 	}
 
 	logging(LOG_VERBOSE, "Verify that WRITESAME16 ANCHOR==1 + UNMAP==0 is invalid");
-	ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
-					    block_size, 1,
-					    1, 0, 0, 0, buf);
+	ret = writesame16(iscsic, tgt_lun, 0,
+			  block_size, 1, 1, 0, 0, 0, buf,
+			  EXPECT_INVALID_FIELD_IN_CDB);
 	CU_ASSERT_EQUAL(ret, 0);
 
 
@@ -124,13 +124,13 @@ test_writesame16_unmap(void)
 		logging(LOG_VERBOSE, "Test WRITESAME16 ANCHOR==1 + UNMAP==0");
 		memset(buf, 0, block_size);
 		ret = writesame16(iscsic, tgt_lun, 0,
-				  block_size, 1,
-				  1, 1, 0, 0, buf);
+				  block_size, 1, 1, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 	} else {
 		logging(LOG_VERBOSE, "Test WRITESAME16 ANCHOR==1 + UNMAP==0 no ANC_SUP so expecting to fail");
-		ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
-						    block_size, 1,
-						    1, 1, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, 0,
+				  block_size, 1, 1, 1, 0, 0, buf,
+				  EXPECT_INVALID_FIELD_IN_CDB);
 	}
 
 	CU_ASSERT_EQUAL(ret, 0);
@@ -162,8 +162,8 @@ test_writesame16_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
 		memset(buf, 0, block_size);
 		ret = writesame16(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -188,9 +188,9 @@ test_writesame16_unmap(void)
 			"INVALID_FIELD_IN_CDB.");
 
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
-		ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, 0,
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_INVALID_FIELD_IN_CDB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
@@ -213,8 +213,8 @@ test_writesame16_unmap(void)
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
 		memset(buf, 0, block_size);
 		ret = writesame16(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_STATUS_GOOD);
 		CU_ASSERT_EQUAL(ret, 0);
 
 		if (rc16->lbprz) {
@@ -239,9 +239,9 @@ test_writesame16_unmap(void)
 			"INVALID_FIELD_IN_CDB.");
 
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
-		ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
-				  block_size, i,
-				  0, 1, 0, 0, buf);
+		ret = writesame16(iscsic, tgt_lun, 0,
+				  block_size, i, 0, 1, 0, 0, buf,
+				  EXPECT_INVALID_FIELD_IN_CDB);
 		CU_ASSERT_EQUAL(ret, 0);
 	}
 
diff --git a/test-tool/test_writesame16_unmap_unaligned.c b/test-tool/test_writesame16_unmap_unaligned.c
index 41d8ab5..8696fe3 100644
--- a/test-tool/test_writesame16_unmap_unaligned.c
+++ b/test-tool/test_writesame16_unmap_unaligned.c
@@ -42,7 +42,8 @@ test_writesame16_unmap_unaligned(void)
 	for (i = 1; i < lbppb; i++) {
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16 at LBA:%d", lbppb - i, i);
 		ret = writesame16(iscsic, tgt_lun, i, 0, lbppb - i,
-				  0, 1, 0, 0, NULL);
+				  0, 1, 0, 0, NULL,
+				  EXPECT_STATUS_GOOD);
 		if (ret == -2) {
 			logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
diff --git a/test-tool/test_writesame16_unmap_until_end.c b/test-tool/test_writesame16_unmap_until_end.c
index 2ed02a4..c29c08a 100644
--- a/test-tool/test_writesame16_unmap_until_end.c
+++ b/test-tool/test_writesame16_unmap_until_end.c
@@ -52,8 +52,8 @@ test_writesame16_unmap_until_end(void)
 			      EXPECT_STATUS_GOOD);
 		logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
 		ret = writesame16(iscsic, tgt_lun, num_blocks - i,
-				  0, i,
-				  0, 1, 0, 0, NULL);
+				  0, i, 0, 1, 0, 0, NULL,
+				  EXPECT_STATUS_GOOD);
 		if (ret == -2) {
 			logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
 			CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
diff --git a/test-tool/test_writesame16_unmap_vpd.c b/test-tool/test_writesame16_unmap_vpd.c
index 4489eea..90a533d 100644
--- a/test-tool/test_writesame16_unmap_vpd.c
+++ b/test-tool/test_writesame16_unmap_vpd.c
@@ -44,9 +44,8 @@ test_writesame16_unmap_vpd(void)
 	logging(LOG_VERBOSE, "Unmap 1 block using WRITESAME16");
 	memset(buf, 0, block_size);
 	ret = writesame16(iscsic, tgt_lun, 0,
-			  block_size, 1,
-			  0, 1, 0, 0, buf);
-
+			  block_size, 1, 0, 1, 0, 0, buf,
+			  EXPECT_STATUS_GOOD);
 	if (ret != 0) {
 		logging(LOG_VERBOSE, "WRITESAME16 UNMAP is not available. "
 			"Verify that VPD settings reflect this.");
diff --git a/test-tool/test_writesame16_wrprotect.c b/test-tool/test_writesame16_wrprotect.c
index 8128ef5..55c3b7e 100644
--- a/test-tool/test_writesame16_wrprotect.c
+++ b/test-tool/test_writesame16_wrprotect.c
@@ -45,9 +45,9 @@ test_writesame16_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 = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
-							    block_size, 1,
-							    0, 0, i, 0, buf);
+			ret = writesame16(iscsic, tgt_lun, 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");