/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * Test a few different bits of the status code string generation and see that
 * we get something expected. Note, we try to avoid using the existing constants
 * that we have for the sct / sc when testing the corresponding entries so
 * someone can more so copy and paste entries from the spec and be less tempted
 * to copy data from the implementation.
 */

#include <stdbool.h>
#include <stdlib.h>
#include <err.h>
#include <stdio.h>
#include <strings.h>
#include <sys/sysmacros.h>
#include <libnvme.h>

typedef struct {
	uint32_t st_code;
	const char *st_str;
} sct_test_t;

static const sct_test_t sct_tests[] = { {
	.st_code = 0,
	.st_str = "generic command status",
}, {
	.st_code = 7,
	.st_str = "vendor specific"
}, {
	.st_code = 0x23,
	.st_str = "unknown status type"
}, {
	.st_code = 0x169,
	.st_str = "unknown status type"
} };

typedef struct {
	nvme_csi_t sc_csi;
	uint32_t sc_sct;
	uint32_t sc_sc;
	const char *sc_str;
} sc_test_t;

static const sc_test_t sc_tests[] = { {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0x0,
	.sc_str = "successful completion"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0x2,
	.sc_str = "invalid field in command"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0xb,
	.sc_str = "invalid namespace or format"
}, {
	/*
	 * This is a purposefully bad CSI, but the CSI shouldn't matter for this
	 * code.
	 */
	.sc_csi = 0xff,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0xb,
	.sc_str = "invalid namespace or format"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0x7f,
	.sc_str = "unknown status code",
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0x80,
	.sc_str = "lba out of range"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0x82,
	.sc_str = "namespace not ready"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0xbf,
	.sc_str = "unknown command set specific general status code"

}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_GENERIC,
	.sc_sc = 0xff,
	.sc_str = "generic vendor specific status code"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0x6,
	.sc_str = "invalid firmware slot"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0x9,
	.sc_str = "invalid log page"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0x6f,
	.sc_str = "unknown generic command status code"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0x80,
	.sc_str = "conflicting attributes"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0xbf,
	.sc_str = "unknown command specific, I/O command set specific status "
	    "code",
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_SPECIFIC,
	.sc_sc = 0xff,
	.sc_str = "command specific vendor specific status code"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_INTEGRITY,
	.sc_sc = 0x80,
	.sc_str = "write fault"
}, {
	.sc_csi = 0x23,
	.sc_sct = NVME_CQE_SCT_INTEGRITY,
	.sc_sc = 0x80,
	.sc_str = "write fault"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_INTEGRITY,
	.sc_sc = 0x0,
	.sc_str = "unknown media and data integrity status code"
}, {
	.sc_csi = NVME_CSI_NVM,
	.sc_sct = NVME_CQE_SCT_INTEGRITY,
	.sc_sc = 0xff,
	.sc_str = "vendor specific media and data integrity status code"
} };

static bool
sct_test_one(const sct_test_t *test)
{
	const char *str = nvme_scttostr(NULL, test->st_code);
	if (strcmp(str, test->st_str) != 0) {
		warnx("TEST FAILED: sct 0x%x was translated to string %s, "
		    "not %s", test->st_code, str, test->st_str);
		return (false);
	}

	(void) printf("TEST PASSED: sct 0x%x successfully translated\n",
	    test->st_code);
	return (true);
}

static bool
sc_test_one(const sc_test_t *test)
{
	const char *str = nvme_sctostr(NULL, test->sc_csi, test->sc_sct,
	    test->sc_sc);
	if (strcmp(str, test->sc_str) != 0) {
		warnx("TEST FAILED: csi/sct/sc 0x%x/0x%x/0x%x was translated "
		    "to string %s, not %s", test->sc_csi, test->sc_sct,
		    test->sc_sc, str, test->sc_str);
		return (false);
	}

	(void) printf("TEST PASSED: csi/sct/sc 0x%x/0x%x/0x%x successfully "
	    "translated\n", test->sc_csi, test->sc_sct, test->sc_sc);

	return (true);
}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	for (size_t i = 0; i < ARRAY_SIZE(sct_tests); i++) {
		if (!sct_test_one(&sct_tests[i])) {
			ret = EXIT_FAILURE;
		}
	}

	for (size_t i = 0; i < ARRAY_SIZE(sc_tests); i++) {
		if (!sc_test_one(&sc_tests[i])) {
			ret = EXIT_FAILURE;
		}
	}

	return (ret);
}